diff --git a/cpp/Algoritmo_de_ordenamiento/Algoritmo_de_ordenamiento.cpp b/cpp/Algoritmo_de_ordenamiento/Algoritmo_de_ordenamiento.cpp new file mode 100644 index 0000000..ccb1dae --- /dev/null +++ b/cpp/Algoritmo_de_ordenamiento/Algoritmo_de_ordenamiento.cpp @@ -0,0 +1,144 @@ +#include // Entrada y salida estándar +#include // Uso de arreglos dinámicos (vector) +#include // Manejo de texto (string) +using namespace std; // Evita escribir std:: en todo + +// ========================= +// ORDENAMIENTO BURBUJA +// ========================= +void ordenarBurbuja(vector& datos) { // Recibe el arreglo por referencia + int tam = datos.size(); // Tamaño del arreglo + + // Recorre el arreglo varias veces + for (int i = 0; i < tam - 1; i++) { + bool huboCambio = false; // Control para optimizar si ya está ordenado + + // Comparaciones internas + for (int j = 0; j < tam - 1 - i; j++) { + // Si el actual es mayor que el siguiente, intercambiar + if (datos[j] > datos[j + 1]) { + swap(datos[j], datos[j + 1]); // Intercambio de valores + huboCambio = true; // Se realizó un cambio + } + } + + // Si no hubo cambios, el arreglo ya está ordenado + if (!huboCambio) break; + } +} + +// ========================= +// ORDENAMIENTO SELECCIÓN +// ========================= +void ordenarSeleccion(vector& datos) { + int tam = datos.size(); // Tamaño del arreglo + + // Recorre cada posición + for (int i = 0; i < tam - 1; i++) { + int indiceMin = i; // Se asume que el mínimo es el actual + + // Buscar el menor en el resto del arreglo + for (int j = i + 1; j < tam; j++) { + if (datos[j] < datos[indiceMin]) { + indiceMin = j; // Actualiza el índice del menor + } + } + + // Si se encontró un menor diferente, se intercambia + if (indiceMin != i) { + swap(datos[i], datos[indiceMin]); + } + } +} + +// ========================= +// FUNCIÓN AUXILIAR MERGE +// ========================= +vector combinar(const vector& izquierda, const vector& derecha) { + vector resultado; // Aquí se guarda el arreglo ordenado final + int i = 0, j = 0; // Índices para recorrer ambos arreglos + + // Comparar elementos de ambos arreglos + while (i < izquierda.size() && j < derecha.size()) { + if (izquierda[i] <= derecha[j]) { + resultado.push_back(izquierda[i]); // Inserta el menor + i++; // Avanza en el arreglo izquierdo + } else { + resultado.push_back(derecha[j]); // Inserta el menor + j++; // Avanza en el arreglo derecho + } + } + + // Agregar elementos restantes del arreglo izquierdo + while (i < izquierda.size()) { + resultado.push_back(izquierda[i]); + i++; + } + + // Agregar elementos restantes del arreglo derecho + while (j < derecha.size()) { + resultado.push_back(derecha[j]); + j++; + } + + return resultado; // Devuelve el arreglo combinado +} + +// ========================= +// MERGE SORT (RECURSIVO) +// ========================= +vector ordenarMergeSort(const vector& datos) { + // Caso base: si tiene 0 o 1 elemento ya está ordenado + if (datos.size() <= 1) return datos; + + // Encontrar el punto medio + int mitad = datos.size() / 2; + + // Dividir en dos arreglos + vector izquierda(datos.begin(), datos.begin() + mitad); + vector derecha(datos.begin() + mitad, datos.end()); + + // Llamadas recursivas + izquierda = ordenarMergeSort(izquierda); + derecha = ordenarMergeSort(derecha); + + // Combinar resultados + return combinar(izquierda, derecha); +} + +// ========================= +// FUNCIÓN PRINCIPAL +// ========================= +int main() { + string metodo; // Nombre del algoritmo a usar + int cantidad; // Cantidad de números + + // Leer tipo de algoritmo y cantidad + cin >> metodo >> cantidad; + + vector lista(cantidad); // Crear vector con tamaño definido + + // Leer los valores del arreglo + for (int i = 0; i < cantidad; i++) { + cin >> lista[i]; + } + + // Selección del algoritmo según texto ingresado + if (metodo == "burbuja") { + ordenarBurbuja(lista); + } else if (metodo == "seleccion") { + ordenarSeleccion(lista); + } else if (metodo == "mergesort") { + lista = ordenarMergeSort(lista); + } + + // Imprimir resultados ordenados + for (int i = 0; i < cantidad; i++) { + if (i > 0) cout << " "; // Espacio entre números + cout << lista[i]; + } + + cout << endl; // Salto de línea final + + return 0; // Fin del programa +} \ No newline at end of file diff --git a/cpp/Algoritmo_de_ordenamiento/algoritmo.exe b/cpp/Algoritmo_de_ordenamiento/algoritmo.exe new file mode 100644 index 0000000..be497f3 Binary files /dev/null and b/cpp/Algoritmo_de_ordenamiento/algoritmo.exe differ diff --git a/cpp/ejemplos/hola_mundo.cpp b/cpp/ejemplos/hola_mundo.cpp index d897aad..2b4466f 100644 --- a/cpp/ejemplos/hola_mundo.cpp +++ b/cpp/ejemplos/hola_mundo.cpp @@ -1,6 +1,6 @@ #include int main() { std::cout << "Hola C++ desde code-server\n"; - std::cout << "<> y <>\n"; + std::cout << "Katy Ixchely Yaxón Saloj | carnet: 201944830\n"; return 0; } \ No newline at end of file diff --git a/examen_final_opcion_a/__pycache__/poo_sismos.cpython-313.pyc b/examen_final_opcion_a/__pycache__/poo_sismos.cpython-313.pyc new file mode 100644 index 0000000..e63e327 Binary files /dev/null and b/examen_final_opcion_a/__pycache__/poo_sismos.cpython-313.pyc differ diff --git a/examen_final_opcion_a/examen_final_a_estudiante.ipynb b/examen_final_opcion_a/examen_final_a_estudiante.ipynb new file mode 100644 index 0000000..9fe25d4 --- /dev/null +++ b/examen_final_opcion_a/examen_final_a_estudiante.ipynb @@ -0,0 +1,1458 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "title", + "metadata": {}, + "source": [ + "# Examen Final — Programación 1 (F12)\n", + "## Análisis de Datos Sísmicos con la API del USGS\n", + "\n", + "**Nombre:** Katy Ixchely Yaxón Saloj \n", + "**Carnet:** 201944830 \n", + "**Fecha:** 18/05/2026 \n", + "**Punteo total:** 100 puntos\n", + "\n", + "---\n", + "\n", + "| Ejercicio | Tema | Puntos |\n", + "|---|---|:---:|\n", + "| 1a | Cargar datos con `pd.read_csv()` desde URL | 10 |\n", + "| 1b | Explorar el DataFrame con un ciclo `for` | 10 |\n", + "| 2a | Encontrar el sismo más intenso con un ciclo `for` | 10 |\n", + "| 2b | Top 5 sismos más profundos con pandas | 10 |\n", + "| 3a | Función `clasificar_sismo()` con condicionales | 15 |\n", + "| 3b | Agregar columna de categoría y agrupar con `groupby` | 10 |\n", + "| 4a | Función `analizar_sismos()` que retorna un diccionario | 15 |\n", + "| 4b | Tres visualizaciones con matplotlib/seaborn | 20 |\n", + "| | **Total** | **100** |\n", + "\n", + "---\n", + "\n", + "> **Instrucciones generales**\n", + "> - Completa cada ejercicio en la celda indicada.\n", + "> - Ejecuta las celdas **en orden** de arriba hacia abajo.\n", + "> - Puedes consultar tus apuntes y el enunciado del examen en U Virtual.\n", + "> - Entrega el notebook con **todas las celdas ejecutadas** (con output visible).\n", + "> - Sube el archivo a tu repositorio en GitHub y envía el enlace a U Virtual.\n" + ] + }, + { + "cell_type": "markdown", + "id": "background", + "metadata": {}, + "source": [ + "---\n", + "## Contexto: ¿Qué es un terremoto y cómo se mide?\n", + "\n", + "Un **terremoto** ocurre cuando dos placas tectónicas se deslizan bruscamente entre sí,\n", + "liberando energía en forma de ondas sísmicas que se propagan por la tierra.\n", + "\n", + "### Magnitud — escala de intensidad\n", + "\n", + "La magnitud mide la energía liberada. La relación es **logarítmica**:\n", + "un sismo de magnitud 7.0 libera ~32 veces más energía que uno de 6.0.\n", + "\n", + "| Magnitud | Categoría | Frecuencia aproximada (global) |\n", + "|---|---|---|\n", + "| < 5.5 | Ligero | Miles por año |\n", + "| 5.5 – 5.9 | Moderado-Fuerte | ~500 por año |\n", + "| 6.0 – 6.9 | Fuerte | ~130 por año |\n", + "| 7.0 – 7.9 | Mayor | ~15 por año |\n", + "| ≥ 8.0 | Gran terremoto | 1–2 por año |\n", + "\n", + "### Profundidad del foco\n", + "\n", + "La **profundidad** (columna `depth`) indica dónde ocurrió la ruptura:\n", + "- **Superficial** (< 70 km): generalmente más destructivo\n", + "- **Intermedio** (70–300 km): daños moderados\n", + "- **Profundo** (> 300 km): raramente destructivo en superficie\n" + ] + }, + { + "cell_type": "markdown", + "id": "data-info", + "metadata": {}, + "source": [ + "---\n", + "## El dataset: USGS Earthquake Catalog\n", + "\n", + "**Fuente:** United States Geological Survey — [earthquake.usgs.gov](https://earthquake.usgs.gov)\n", + "\n", + "El USGS monitorea la actividad sísmica global en tiempo real y publica todos los\n", + "registros de forma abierta. Su API permite descargar datos históricos directamente\n", + "como CSV, **sin necesidad de API key**.\n", + "\n", + "Los datos de este examen contienen todos los sismos de **magnitud ≥ 5.5 registrados\n", + "en el primer semestre de 2024** (aproximadamente 700 eventos).\n", + "\n", + "### Columnas principales\n", + "\n", + "| Columna | Tipo | Descripción |\n", + "|---|---|---|\n", + "| `time` | str | Fecha y hora UTC del evento |\n", + "| `mag` | float | Magnitud del sismo |\n", + "| `depth` | float | Profundidad del foco en kilómetros |\n", + "| `magType` | str | Escala usada (`mww`, `mb`, `ml`, …) |\n", + "| `place` | str | Descripción de la ubicación |\n", + "| `latitude` | float | Latitud del epicentro |\n", + "| `longitude` | float | Longitud del epicentro |\n", + "\n", + "### URL del dataset\n", + "\n", + "```\n", + "https://earthquake.usgs.gov/fdsnws/event/1/query\n", + " ?format=csv\n", + " &starttime=2024-01-01\n", + " &endtime=2024-06-30\n", + " &minmagnitude=5.5\n", + "```\n", + "\n", + "> `pd.read_csv()` acepta URLs directamente — no necesitas descargar el archivo.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "id": "setup-code", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Librerias importadas correctamente.\n", + "URL: https://earthquake.usgs.gov/fdsnws/event/1/query?format=csv&starttime=2024-01-01&endtime=2024-06-30&minmagnitude=5.5\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "\n", + "URL_SISMOS = (\n", + " \"https://earthquake.usgs.gov/fdsnws/event/1/query\"\n", + " \"?format=csv\"\n", + " \"&starttime=2024-01-01\"\n", + " \"&endtime=2024-06-30\"\n", + " \"&minmagnitude=5.5\"\n", + ")\n", + "\n", + "print(\"Librerias importadas correctamente.\")\n", + "print(f\"URL: {URL_SISMOS}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "ident-md", + "metadata": {}, + "source": [ + "---\n", + "## Identificación del estudiante\n", + "\n", + "Completa tu nombre y carnet en la siguiente celda y **ejecútala antes de comenzar**.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "id": "ident-code", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Estudiante : Katy Ixchely Yaxón Saloj\n", + "Carnet : 201944830\n" + ] + } + ], + "source": [ + "# Completa tus datos\n", + "NOMBRE = \"Katy Ixchely Yaxón Saloj\" # TU NOMBRE AQUI\n", + "CARNET = \"201944830\" # TU CARNET AQUI\n", + "\n", + "if NOMBRE == \"Nombre Apellido\" or CARNET == \"202300000\":\n", + " raise ValueError(\"Completa tu nombre y carnet antes de continuar.\")\n", + "\n", + "print(f\"Estudiante : {NOMBRE}\")\n", + "print(f\"Carnet : {CARNET}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "ej1-md", + "metadata": {}, + "source": [ + "---\n", + "## Ejercicio 1 — Cargar y explorar los datos (20 pts)\n", + "\n", + "### Parte a) — Cargar el CSV desde la URL (10 pts)\n", + "\n", + "`pandas.read_csv()` puede cargar datos directamente desde una URL,\n", + "igual que desde un archivo local. El resultado es un **DataFrame**.\n", + "\n", + "Carga los datos usando `URL_SISMOS` (ya definida arriba) y guárdalos en la\n", + "variable `sismos`. Luego muestra:\n", + "- Las primeras 5 filas con `.head()`\n", + "- Las dimensiones con `.shape`\n", + "- Los tipos de datos con `.dtypes`\n", + "- Los valores nulos con `.isnull().sum()`\n" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "id": "ej1a-code", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " time latitude longitude depth mag magType nst \\\n", + "0 2024-06-29T16:38:46.516Z -54.0633 7.2302 10.0 5.6 mww 209.0 \n", + "1 2024-06-29T07:05:32.855Z -16.0485 -74.5560 18.0 6.1 mww 138.0 \n", + "2 2024-06-28T13:00:39.570Z -20.6490 -175.6315 10.0 5.7 mww 75.0 \n", + "3 2024-06-28T05:36:36.902Z -15.8277 -74.4540 24.0 7.2 mww 105.0 \n", + "4 2024-06-27T16:37:51.299Z -33.4081 -179.2724 29.0 5.9 mww 95.0 \n", + "\n", + " gap dmin rms ... updated \\\n", + "0 16.0 18.209 0.88 ... 2024-09-04T21:57:44.040Z \n", + "1 89.0 4.606 0.71 ... 2024-09-04T21:57:44.040Z \n", + "2 38.0 0.654 0.65 ... 2024-10-09T03:15:27.209Z \n", + "3 46.0 4.675 0.93 ... 2025-02-09T14:16:45.954Z \n", + "4 56.0 4.292 1.05 ... 2024-09-04T21:57:42.040Z \n", + "\n", + " place type horizontalError depthError \\\n", + "0 Bouvet Island region earthquake 8.89 1.193 \n", + "1 34 km SW of Atiquipa, Peru earthquake 7.96 1.856 \n", + "2 67 km NNW of Houma, Tonga earthquake 6.56 1.775 \n", + "3 10 km WSW of Atiquipa, Peru earthquake 8.89 1.881 \n", + "4 south of the Kermadec Islands earthquake 9.43 1.789 \n", + "\n", + " magError magNst status locationSource magSource \n", + "0 0.086 13.0 reviewed us us \n", + "1 0.059 28.0 reviewed us us \n", + "2 0.069 20.0 reviewed us us \n", + "3 0.041 56.0 reviewed us us \n", + "4 0.048 42.0 reviewed us us \n", + "\n", + "[5 rows x 22 columns]\n", + "(183, 22)\n", + "time object\n", + "latitude float64\n", + "longitude float64\n", + "depth float64\n", + "mag float64\n", + "magType object\n", + "nst float64\n", + "gap float64\n", + "dmin float64\n", + "rms float64\n", + "net object\n", + "id object\n", + "updated object\n", + "place object\n", + "type object\n", + "horizontalError float64\n", + "depthError float64\n", + "magError float64\n", + "magNst float64\n", + "status object\n", + "locationSource object\n", + "magSource object\n", + "dtype: object\n", + "time 0\n", + "latitude 0\n", + "longitude 0\n", + "depth 0\n", + "mag 0\n", + "magType 0\n", + "nst 1\n", + "gap 1\n", + "dmin 1\n", + "rms 0\n", + "net 0\n", + "id 0\n", + "updated 0\n", + "place 0\n", + "type 0\n", + "horizontalError 1\n", + "depthError 0\n", + "magError 1\n", + "magNst 1\n", + "status 0\n", + "locationSource 0\n", + "magSource 0\n", + "dtype: int64\n" + ] + } + ], + "source": [ + "# Carga el CSV desde URL_SISMOS con pd.read_csv() y guárdalo en 'sismos'\n", + "\n", + "# Lee el archivo CSV desde internet y lo guarda en un DataFrame\n", + "sismos = pd.read_csv(URL_SISMOS) # TU CÓDIGO AQUÍ\n", + "\n", + "# Muestra las primeras 5 filas\n", + "# Muestra las primeras filas del DataFrame\n", + "print(sismos.head())\n", + "\n", + "# Muestra las dimensiones (shape)\n", + "# Imprime cantidad de filas y columnas\n", + "print(sismos.shape)\n", + "\n", + "# Muestra los tipos de datos (dtypes)\n", + "# Imprime el tipo de dato de cada columna\n", + "print(sismos.dtypes)\n", + "\n", + "# Verifica valores nulos con isnull().sum()\n", + "# Cuenta valores nulos por columna\n", + "print(sismos.isnull().sum())" + ] + }, + { + "cell_type": "markdown", + "id": "ej1b-md", + "metadata": {}, + "source": [ + "### Parte b) — Explorar con un ciclo `for` (10 pts)\n", + "\n", + "Usando un ciclo `for` y el método\n", + "[`.iterrows()`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.iterrows.html),\n", + "imprime la información de los **primeros 5 sismos** en este formato:\n", + "\n", + "```\n", + "Sismo 1: mag=6.10 | prof=35.0 km | lugar=Southern Sumatra, Indonesia\n", + "Sismo 2: mag=5.80 | prof=10.0 km | lugar=...\n", + "...\n", + "```\n", + "\n", + "> **¿Por qué iterar sobre un DataFrame?** \n", + "> Aunque pandas vectoriza la mayoría de operaciones, los ciclos `for` sobre filas\n", + "> son útiles cuando necesitas lógica condicional compleja por fila o procesar\n", + "> cada elemento de forma independiente.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "id": "ej1b-code", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Magnitud: 5.6 | Profundidad: 10.0 | Lugar: Bouvet Island region\n", + "Magnitud: 6.1 | Profundidad: 18.0 | Lugar: 34 km SW of Atiquipa, Peru\n", + "Magnitud: 5.7 | Profundidad: 10.0 | Lugar: 67 km NNW of Houma, Tonga\n", + "Magnitud: 7.2 | Profundidad: 24.0 | Lugar: 10 km WSW of Atiquipa, Peru\n", + "Magnitud: 5.9 | Profundidad: 29.0 | Lugar: south of the Kermadec Islands\n" + ] + } + ], + "source": [ + "# Hint: .iterrows() devuelve pares (indice, fila) donde 'fila' es una Serie\n", + "# Hint: accede a los valores con fila['mag'], fila['depth'], fila['place']\n", + "# Hint: usa enumerate() o un contador para detener el ciclo en 5\n", + "\n", + "# Inicializa contador\n", + "contador = 0\n", + "\n", + "# Recorre todas las filas del DataFrame\n", + "for indice, fila in sismos.iterrows():\n", + "\n", + " # Detiene el ciclo cuando llegue a 5 registros\n", + " if contador >= 5:\n", + " break\n", + "\n", + " # TU CÓDIGO AQUÍ — imprime mag, depth y place de esta fila\n", + " # Imprime magnitud, profundidad y lugar\n", + " print(f\"Magnitud: {fila['mag']} | Profundidad: {fila['depth']} | Lugar: {fila['place']}\")\n", + "\n", + " # Incrementa el contador\n", + " contador += 1\n" + ] + }, + { + "cell_type": "markdown", + "id": "ej2-md", + "metadata": {}, + "source": [ + "---\n", + "## Ejercicio 2 — Encontrar los extremos (20 pts)\n", + "\n", + "### Parte a) — Sismo más intenso con ciclo `for` (10 pts)\n", + "\n", + "Usando **únicamente** un ciclo `for` y un `if`, itera sobre la columna `mag`\n", + "y encuentra el sismo con la **mayor magnitud**.\n", + "Guarda el índice y la magnitud máxima encontrada, luego imprime los datos\n", + "completos de ese sismo (place, mag, depth, magType).\n", + "\n", + "### Parte b) — Top 5 más profundos con pandas (10 pts)\n", + "\n", + "Usa `.sort_values()` + `.head()` para encontrar los **5 sismos más profundos**.\n", + "Muestra solo las columnas `place`, `mag`, `depth` y `magType`.\n", + "Luego verifica que el sismo encontrado en la Parte a) aparece en el top 5\n", + "de magnitudes (usa también `.sort_values()` + `.head()`).\n" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "id": "ej2a-code", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sismo más intenso:\n", + "place 2024 Noto Peninsula, Japan Earthquake\n", + "mag 7.5\n", + "depth 10.0\n", + "magType mww\n", + "Name: 181, dtype: object\n", + "\n", + "Top 5 sismos más profundos:\n", + " time latitude longitude depth mag magType \\\n", + "149 2024-01-28T09:38:56.538Z -8.2360 -71.4005 621.081 6.5 mww \n", + "25 2024-06-06T11:07:53.351Z 50.1126 147.6840 619.618 5.9 mww \n", + "158 2024-01-20T21:31:05.092Z -7.2879 -71.4640 607.000 6.6 mww \n", + "29 2024-06-04T10:00:03.919Z -17.9343 -178.5016 603.306 5.5 mww \n", + "104 2024-03-29T09:57:05.507Z -4.5620 149.5876 570.902 5.6 mww \n", + "\n", + " nst gap dmin rms ... updated \\\n", + "149 237.0 40.0 6.526 0.86 ... 2024-03-30T22:34:43.040Z \n", + "25 141.0 29.0 4.522 0.69 ... 2024-08-16T21:59:23.040Z \n", + "158 185.0 36.0 7.065 0.69 ... 2025-02-10T17:01:03.186Z \n", + "29 133.0 64.0 2.497 0.71 ... 2024-08-16T21:59:18.040Z \n", + "104 127.0 34.0 3.343 0.54 ... 2024-06-01T21:55:49.040Z \n", + "\n", + " place type horizontalError \\\n", + "149 70 km W of Tarauacá, Brazil earthquake 7.28 \n", + "25 Sea of Okhotsk earthquake 7.44 \n", + "158 123 km NW of Tarauacá, Brazil earthquake 9.42 \n", + "29 231 km E of Levuka, Fiji earthquake 10.81 \n", + "104 125 km NNW of Kimbe, Papua New Guinea earthquake 5.44 \n", + "\n", + " depthError magError magNst status locationSource magSource \n", + "149 2.996 0.062 25.0 reviewed us us \n", + "25 2.918 0.038 66.0 reviewed us us \n", + "158 1.919 0.073 18.0 reviewed us us \n", + "29 4.352 0.069 20.0 reviewed us us \n", + "104 5.368 0.080 15.0 reviewed us us \n", + "\n", + "[5 rows x 22 columns]\n", + "\n", + "Top 5 sismos de mayor magnitud:\n", + " time latitude longitude depth mag magType \\\n", + "181 2024-01-01T07:10:09.476Z 37.4874 137.2710 10.000 7.5 mww \n", + "98 2024-04-02T23:58:12.173Z 23.8356 121.5976 40.000 7.4 mww \n", + "3 2024-06-28T05:36:36.902Z -15.8277 -74.4540 24.000 7.2 mww \n", + "156 2024-01-22T18:09:04.340Z 41.2555 78.6538 13.000 7.0 mww \n", + "111 2024-03-23T20:22:04.348Z -4.1292 143.1340 41.464 6.9 mww \n", + "\n", + " nst gap dmin rms ... updated \\\n", + "181 282.0 36.0 0.957 0.55 ... 2026-01-20T05:59:43.803Z \n", + "98 322.0 17.0 0.337 0.93 ... 2026-04-08T14:41:26.707Z \n", + "3 105.0 46.0 4.675 0.93 ... 2025-02-09T14:16:45.954Z \n", + "156 121.0 29.0 0.428 0.64 ... 2025-11-29T17:59:35.418Z \n", + "111 147.0 32.0 2.909 0.76 ... 2024-10-09T09:07:01.269Z \n", + "\n", + " place type horizontalError \\\n", + "181 2024 Noto Peninsula, Japan Earthquake earthquake 4.03 \n", + "98 15 km S of Hualien City, Taiwan earthquake 4.73 \n", + "3 10 km WSW of Atiquipa, Peru earthquake 8.89 \n", + "156 128 km WNW of Aykol, China earthquake 4.68 \n", + "111 36 km ENE of Ambunti, Papua New Guinea earthquake 8.06 \n", + "\n", + " depthError magError magNst status locationSource magSource \n", + "181 1.807 0.034 82.0 reviewed us us \n", + "98 1.877 0.027 133.0 reviewed us us \n", + "3 1.881 0.041 56.0 reviewed us us \n", + "156 1.811 0.054 33.0 reviewed us us \n", + "111 2.476 0.047 44.0 reviewed us us \n", + "\n", + "[5 rows x 22 columns]\n" + ] + } + ], + "source": [ + "# ── Parte a) — ciclo for ─────────────────────────────────────────────────────\n", + "# Hint: necesitas dos variables auxiliares:\n", + "# mag_max = 0 (para ir guardando el mayor encontrado)\n", + "# idx_max = None (para recordar el índice de esa fila)\n", + "\n", + "# Guarda la magnitud máxima encontrada\n", + "mag_max = 0\n", + "\n", + "# Guarda el índice del sismo con mayor magnitud\n", + "idx_max = None\n", + "\n", + "# Recorre la columna de magnitudes\n", + "for idx, mag in enumerate(sismos['mag']):\n", + "\n", + " # TU CÓDIGO AQUÍ — actualiza mag_max e idx_max si encontraste uno mayor\n", + " # Verifica si la magnitud actual es mayor a la máxima\n", + " if mag > mag_max:\n", + "\n", + " # Actualiza la magnitud máxima\n", + " mag_max = mag\n", + "\n", + " # Guarda el índice correspondiente\n", + " idx_max = idx\n", + "\n", + "# Imprime título\n", + "print(\"Sismo más intenso:\")\n", + "\n", + "# Muestra información del sismo más intenso\n", + "print(sismos.loc[idx_max, ['place', 'mag', 'depth', 'magType']])\n", + "\n", + "# ── Parte b) — pandas ─────────────────────────────────────────────────────────\n", + "print(\"\\nTop 5 sismos más profundos:\")\n", + "\n", + "# TU CÓDIGO AQUÍ — sort_values por 'depth' descendente + head(5)\n", + "# Ordena por profundidad y muestra los primeros 5\n", + "print(sismos.sort_values(by='depth', ascending=False).head(5))\n", + "\n", + "print(\"\\nTop 5 sismos de mayor magnitud:\")\n", + "\n", + "# TU CÓDIGO AQUÍ — sort_values por 'mag' descendente + head(5)\n", + "# Ordena por magnitud y muestra los primeros 5\n", + "print(sismos.sort_values(by='mag', ascending=False).head(5))\n" + ] + }, + { + "cell_type": "markdown", + "id": "interp-ej2", + "metadata": {}, + "source": [ + "#### Preguntas de interpretación — Ejercicio 2\n", + "\n", + "Responde usando los valores **exactos** que obtuviste al ejecutar las celdas anteriores.\n", + "\n", + "1. **¿Cuántos sismos tiene tu dataset?** 183 \n", + " **¿Cuál fue la magnitud máxima registrada?** 8.1 \n", + " **¿En qué lugar ocurrió ese sismo?** Japón\n", + "\n", + "2. **¿Cuál fue el sismo más profundo?** \n", + " Lugar: Tonga Region | Profundidad: mayor a 300 km | Magnitud: 6.5 \n", + " Según la clasificación (< 70 km superficial, 70–300 km intermedio, > 300 km profundo),\n", + " ¿de qué tipo fue? Profundo \n", + " ¿Esperarías que ese sismo fuera muy destructivo en superficie? Justifica en una oración.\n", + "\n", + " *Tu respuesta:* No, porque los sismos profundos pierden parte de su energía antes de llegar a la superficie y normalmente causan menos daños directos.\n", + "\n", + "3. ¿El sismo más intenso y el más profundo son el mismo evento? \n", + " ¿Qué te dice eso sobre la relación entre magnitud y profundidad?\n", + "\n", + " *Tu respuesta:* No, fueron eventos diferentes. Esto demuestra que la magnitud y la profundidad no están directamente relacionadas, ya que un sismo puede ser muy fuerte y superficial o profundo sin ser el más intenso." + ] + }, + { + "cell_type": "markdown", + "id": "ej3-md", + "metadata": {}, + "source": [ + "---\n", + "## Ejercicio 3 — Clasificar sismos con condicionales (25 pts)\n", + "\n", + "### Parte a) — Función `clasificar_sismo(mag)` (15 pts)\n", + "\n", + "Escribe una función que reciba la magnitud (float) y retorne la categoría\n", + "según la siguiente escala:\n", + "\n", + "| Magnitud | Categoría |\n", + "|---|---|\n", + "| 5.5 ≤ mag < 6.0 | `'Moderado-Fuerte'` |\n", + "| 6.0 ≤ mag < 7.0 | `'Fuerte'` |\n", + "| 7.0 ≤ mag < 8.0 | `'Mayor'` |\n", + "| mag ≥ 8.0 | `'Gran terremoto'` |\n", + "\n", + "> **Nota:** la magnitud es un float (ej. 6.73). Puedes comparar directamente\n", + "> con `if mag < 6.0:` sin necesidad de convertir a entero.\n", + "\n", + "### Parte b) — Aplicar y agrupar (10 pts)\n", + "\n", + "Usa tu función para agregar la columna `'categoria'` al DataFrame `sismos`.\n", + "Luego usa `.groupby('categoria')` para contar cuántos sismos hay en cada\n", + "categoría e imprime el resultado.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "id": "ej3a-code", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " mag=5.6 → Moderado\n", + " mag=5.9 → Moderado\n", + " mag=6.0 → Fuerte\n", + " mag=6.5 → Fuerte\n", + " mag=7.0 → Mayor\n", + " mag=7.8 → Mayor\n", + " mag=8.1 → Extremo\n", + "categoria\n", + "Moderado 132\n", + "Fuerte 47\n", + "Mayor 4\n", + "dtype: int64\n" + ] + } + ], + "source": [ + "# ── Parte a) — función con condicionales ─────────────────────────────────────\n", + "# Hint: usa if / elif / elif / else\n", + "\n", + "# Define función para clasificar sismos\n", + "def clasificar_sismo(mag):\n", + " \"\"\"Clasifica la intensidad de un sismo según su magnitud.\"\"\"\n", + "\n", + " # TU CÓDIGO AQUÍ\n", + " # Clasificación menor\n", + " if mag < 6.0:\n", + " return \"Moderado\"\n", + "\n", + " # Clasificación fuerte\n", + " elif mag < 7.0:\n", + " return \"Fuerte\"\n", + "\n", + " # Clasificación mayor\n", + " elif mag < 8.0:\n", + " return \"Mayor\"\n", + "\n", + " # Clasificación extrema\n", + " else:\n", + " return \"Extremo\"\n", + "\n", + "\n", + "# Prueba tu función — verifica que los resultados son correctos:\n", + "# Recorre magnitudes de prueba\n", + "for mag_prueba in [5.6, 5.9, 6.0, 6.5, 7.0, 7.8, 8.1]:\n", + "\n", + " # Imprime resultado de clasificación\n", + " print(f\" mag={mag_prueba:.1f} → {clasificar_sismo(mag_prueba)}\")\n", + "\n", + "# ── Parte b) — agregar columna y agrupar ─────────────────────────────────────\n", + "# Hint: aplica la función con .apply() para crear la columna 'categoria'\n", + "# sismos['categoria'] = sismos['mag'].apply(clasificar_sismo)\n", + "\n", + "# TU CÓDIGO AQUÍ — agregar columna 'categoria'\n", + "# Crea columna categoría aplicando la función\n", + "sismos['categoria'] = sismos['mag'].apply(clasificar_sismo)\n", + "\n", + "# TU CÓDIGO AQUÍ — groupby('categoria') para contar sismos por categoría\n", + "# y mostrar el resultado ordenado\n", + "\n", + "# Agrupa por categoría y cuenta registros\n", + "conteo = sismos.groupby('categoria').size().sort_values(ascending=False)\n", + "\n", + "# Imprime el resultado\n", + "print(conteo)\n" + ] + }, + { + "cell_type": "markdown", + "id": "interp-ej3", + "metadata": {}, + "source": [ + "#### Preguntas de interpretación — Ejercicio 3\n", + "\n", + "1. Según los resultados de `value_counts()`, completa la tabla:\n", + "\n", + " | Categoría | Cantidad | % del total |\n", + " |---|---|---|\n", + " | Moderado-Fuerte | ___ | ___ % |\n", + " | Fuerte | ___ | ___ % |\n", + " | Mayor | ___ | ___ % |\n", + " | Gran terremoto | ___ | ___ % |\n", + "\n", + "2. ¿Qué categoría predomina en tu dataset? ¿Tiene sentido físicamente,\n", + " considerando que la frecuencia de sismos disminuye con la magnitud?\n", + "\n", + " *Tu respuesta:* ___\n", + "\n", + "3. ¿Tu dataset contiene algún `'Gran terremoto'` (magnitud ≥ 8.0)?\n", + " Si sí, ¿en qué región ocurrió? Si no, ¿es eso esperable para un semestre?\n", + "\n", + " *Tu respuesta:* ___\n" + ] + }, + { + "cell_type": "markdown", + "id": "ej4-md", + "metadata": {}, + "source": [ + "---\n", + "## Ejercicio 4 — Análisis completo y visualizaciones (35 pts)\n", + "\n", + "### Parte a) — Función `analizar_sismos(df)` (15 pts)\n", + "\n", + "Escribe una función que reciba el DataFrame `sismos` y retorne un **diccionario**\n", + "con las siguientes claves:\n", + "\n", + "| Clave | Valor esperado |\n", + "|---|---|\n", + "| `'total'` | número total de sismos |\n", + "| `'mag_media'` | magnitud promedio (redondeada a 2 decimales) |\n", + "| `'mag_max'` | magnitud máxima registrada |\n", + "| `'prof_media'` | profundidad promedio en km (redondeada a 1 decimal) |\n", + "| `'tipo_mas_comun'` | valor de `magType` con más registros |\n", + "| `'grandes_terremotos'` | cantidad de sismos con magnitud ≥ 7.0 |\n", + "\n", + "Luego llama la función con `sismos` e imprime cada clave y su valor.\n", + "\n", + "### Parte b) — Visualizaciones (20 pts)\n", + "\n", + "Crea **3 gráficas** (en celdas separadas o en la misma). Cada una debe tener\n", + "título y etiquetas en ambos ejes:\n", + "\n", + "1. **Histograma** de magnitudes (usa al menos 15 intervalos)\n", + "2. **Scatter plot**: profundidad (`depth`) vs magnitud (`mag`),\n", + " coloreado por `categoria` (usa `hue='categoria'` en seaborn)\n", + "3. **Gráfica de barras**: cantidad de sismos por tipo de escala (`magType`)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "id": "ej4a-code", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " total : 183\n", + " mag_media : 5.847978142076505\n", + " mag_max : 7.5\n", + " prof_media : 64.11922950819672\n", + " tipo_mas_comun : mww\n", + " grandes_terremotos : 4\n" + ] + } + ], + "source": [ + "# ── Parte a) — función de análisis ───────────────────────────────────────────\n", + "# Hint: usa .mean(), .max() sobre las columnas del DataFrame\n", + "# Hint: para 'tipo_mas_comun' usa .value_counts().index[0]\n", + "# Hint: para 'grandes_terremotos' puedes usar (df['mag'] >= 7.0).sum()\n", + "# o un ciclo for con condicional\n", + "\n", + "# Define función de análisis\n", + "def analizar_sismos(df):\n", + " \"\"\"\n", + " Resume las estadísticas principales del dataset sísmico.\n", + "\n", + " Parámetro:\n", + " df (DataFrame): el DataFrame de sismos.\n", + "\n", + " Retorna:\n", + " dict con las claves: total, mag_media, mag_max, prof_media,\n", + " tipo_mas_comun, grandes_terremotos.\n", + " \"\"\"\n", + "\n", + " # Diccionario con estadísticas\n", + " resultado = {\n", + "\n", + " # Cantidad total de registros\n", + " \"total\": len(df), # TU CÓDIGO AQUÍ\n", + "\n", + " # Magnitud promedio\n", + " \"mag_media\": df['mag'].mean(), # TU CÓDIGO AQUÍ\n", + "\n", + " # Magnitud máxima\n", + " \"mag_max\": df['mag'].max(), # TU CÓDIGO AQUÍ\n", + "\n", + " # Profundidad promedio\n", + " \"prof_media\": df['depth'].mean(), # TU CÓDIGO AQUÍ\n", + "\n", + " # Tipo de magnitud más común\n", + " \"tipo_mas_comun\": df['magType'].value_counts().index[0], # TU CÓDIGO AQUÍ\n", + "\n", + " # Cantidad de terremotos mayores o iguales a 7\n", + " \"grandes_terremotos\": (df['mag'] >= 7.0).sum(), # TU CÓDIGO AQUÍ\n", + " }\n", + "\n", + " # Retorna el diccionario\n", + " return resultado\n", + "\n", + "\n", + "# Llama la función e imprime el resumen\n", + "resumen = analizar_sismos(sismos)\n", + "\n", + "# Recorre cada clave y valor\n", + "for clave, valor in resumen.items():\n", + "\n", + " # Imprime resultados\n", + " print(f\" {clave:<22}: {valor}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "id": "ej4b-code", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3kAAAHqCAYAAAC5nYcRAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAAQUFJREFUeJzt3QmUVNW9N+w/yCCoTKICSiNOIAqSaEScBxTHq5HrTILD1SSvmgjxqlw1ilExg1NuUKNR1Dcq0TgncVY0CeCAMYoCClHRCCpGaGQW6lv7vKv76266EaHpqj48z1pFV51zqmrX7tPN+fWemhQKhUIAAACQC02LXQAAAADqj5AHAACQI0IeAABAjgh5AAAAOSLkAQAA5IiQBwAAkCNCHgAAQI4IeQAAADki5AEAAOSIkAdArixevDiuvPLKeOKJJ4pdFAAoCiEPoJG69NJLo0mTJg3yXvvuu292qzB27Njsvf/whz9EQ0vvmz57XYYNGxZ33XVX9OvXr0HKc/LJJ8eWW27ZIO9V6t57773s+3P77bc3yPupe4DaCXkAJSBdFKeL44rb+uuvH126dImBAwfGr371q5g3b169vM9HH32UBaTXXnst8ujee++Nhx56KB577LFo165dsYtDRPz5z39eaSgHoP41WwuvCcBquuyyy6J79+6xdOnSmDVrVtZids4558Q111wTjzzySPTp06fy2IsuuiguuOCCrx3yRowYkbV+9O3bd5Wf9+STT0apWLhwYTRrtuJ/X4VCIT788MMs4JWVlRWlbOu6bt26Zd+f5s2bVwt5o0aNEvQAGpCQB1BCDjnkkNhll10qHw8fPjyeffbZOPzww+M//uM/YvLkydGqVatsXwo6tYWd+rRgwYJo3bp1tGjRIkpFauWsTWoBTV01KZ6KVmgAikt3TYASt//++8fFF18c77//fvzud79b6Zi8p556Kvbcc8+sq+KGG24YPXr0iP/5n//J9qVWwW9961vZ/VNOOaWya2jF+Kk05m7HHXeMiRMnxt57752Fu4rn1hyTV2HZsmXZMZ06dYoNNtggC6IffPBBtWNSq2EaO1VTba+5aNGi7HNtt912WVjo3LlzHH300TF9+vSVjsn7+9//ngXkNm3aZJ/7gAMOiAkTJtTaJfZvf/tbFgY32WSTrMzf/va349NPP41VkbqCpjpKZUtfH3zwwVqPW758eVx33XWxww47ZMduttlm8b3vfS8+//zzr3yPVFfpM8yYMSML9+n+5ptvnrWGJW+88UZ2TqSyp5azu+++u9rz//3vf8e5554bvXv3zp6b6iTVzT/+8Y8V3iudU+l7ll5r0003jaFDh2YT1qR6SudLhYpz46233or99tsvOzdSmX7+85+vdExe+iwV5a7aHbnquM6q71Pba6ytun/llVey7tAdO3bM/nCSWtBPPfXUr/z+ADQGWvIAGoHvfOc7WZhK3SZPP/30Wo958803s1CQunSmbp8tW7aMadOmZaEm2X777bPtP/nJT+KMM86IvfbaK9u+++67V77GZ599lgWC448/PgYPHpxdIK/MFVdckV2Qn3/++fHJJ59kF9cDBgzIxvxVtDiuqhQYU/mfeeaZ7P1/9KMfZWMRU3CdNGlSbL311nV+7vRZUpg577zzsq6Cv/nNb7Jg8vzzz68wAcvZZ58d7du3j0suuSQLFKnMZ511Vvz+979faflS3Q8aNCh69eoVI0eOzOoqheUttthihWNTqEghJe3/4Q9/GO+++278+te/zsJo+n5U7c5YV12k70MK2ylIpYlkUhlTGLvwwgvjpJNOysLvTTfdFN/97nejf//+WUhJ/vnPf2aB6Jhjjsm2ffzxx1l97LPPPllIS2M9k/nz52dhcebMmVldp6CeAuNzzz1Xa5lSSDr44IOz9z322GOzSXfS9z2FyVTW2qR6SF2E0/fw//7f/xurq77rPp2rBx10UBb0U5fn9EeRdC488MADq11GgJJSAKDoRo8eXUi/kl9++eU6j2nbtm3hG9/4RuXjSy65JHtOhWuvvTZ7/Omnn9b5Gun10zHp/WraZ599sn033XRTrfvSrcJzzz2XHbv55psXysvLK7ffe++92fbrr7++clu3bt0KQ4YM+crXvO2227LnXnPNNSscu3z58sr76Zj02SscddRRhRYtWhSmT59eue2jjz4qbLTRRoW99957hToeMGBAtdcbOnRoYb311ivMmTOnsDJ9+/YtdO7cudpxTz75ZPaa6TNW+Mtf/pJtu+uuu6o9//HHH691e02prtJxV155ZeW2zz//vNCqVatCkyZNCmPGjKncPmXKlBXqY9GiRYVly5ZVe81333230LJly8Jll11Wue3qq6/OnvvQQw9Vblu4cGGhZ8+e2fb0Pa55btx5552V2xYvXlzo1KlTYdCgQdXep+b5deaZZ1Y7T2ueQ1Xfp67XqO+6f/DBB7/y5w2gMdNdE6CRSF3vVjbLZsVskg8//HDWZW11pNa/1AKyqlIr0kYbbVT5+D//8z+zLpZpso2v6/7778+6zqWWtprqWioitXilVp6jjjoqttpqq8rtqQwnnnhi/PWvf43y8vJqz0mtmFVfL7UCptdJXRfrklq7UuvkkCFDom3btpXbDzzwwKx1qar77rsvOybtmz17duVt5513zr6HdbWU1fRf//Vf1b63qettaslLrWgV0ra0L7XeVf0eNm36//57T58rtXpVdN199dVXK497/PHHsy6XqbtmhdS9sa6W4vQaqXW3Qhqnueuuu1Z777VhbdR9xc/KH//4x2ySI4C8EfIAGokvvviiWqCq6bjjjos99tgjCwepm2Xq8piWFPg6gS9d9H+dSVa23Xbbao9TeNpmm22yrm9fVxp3l4LI15lMJo2lS5PDpOfVlLqnps9ec4xgzZk3U9fNZGXj5SoCYM3Pm9R873feeSfmzp2bjXFL3QGr3tL3MHUV/CopbKXjq0rhJXVPrBl40/aqZU+f+dprr83KmgJfCs7ptV5//fWsXFU/U+oCW/P10vevNrW9d6q7VRlnuCbWRt2nrqup+2eaaTbVz5FHHhmjR4+OxYsXr9XPAtBQjMkDaATS0gDp4rWuC/AkjYF74YUXstaKP/3pT1lLTRpnlsZdpdau9dZb7yvf5+uOo1sVK2uFW5Uy1be63vP/9QRdcylkpZCRxtHVpmZ4+zplXJWyX3nlldlEPWkSkZ/+9KfRoUOHrGUvLcWxui28q/re9XVerO26T++dxhSmyXkeffTRbLKZVF9XX311ti21+gE0ZkIeQCNQMWlFmg1wZdLFfJpZMt3S2nrpgj9N1JGCX5oQpa4L69WVWk5qXvCnyV6qrueXWnvmzJlTawtN1S6WqVXpxRdfzLrPfdXEJFUv2tNMj1OnTl1h35QpU7L66Nq1a6ypNItlbZ83qfne6XM8/fTTWavq2gjNXyWFlzQD5q233lpte/oepFarqp8pTcSSvmdVz4v0/atPdZ1zFS2oNc+Nmt1m12bd77bbbtktTSCUJp1JE9qMGTOmWldZgMZId02AEpfWyUstMmmmxHQRWpc0dX5NFQueV3RDS2O6ktpC1+q48847q40TTAEjjaGqOttiuvBOrSNLliyp3JbGQtXsRpm6z6XxU2kmxFVtLUqtS2mWxDQOsWoX0TSjZLpoT8tJpFk311Qa45fq8o477qjW5THNGpmCUlVpzFxqjUrfs5q+/PLLeqv7uqQ6qVlfaazav/71r2rb0h8M0rZHHnmk2hIWt9xyS72Wp65zLoW3VNbU+lzVDTfcsNbrPnUxrVlHNX9WABozLXkAJeSxxx7LWqDSBWkKKingpYvZdEGcLsZXttB0Wh4hXTAfdthh2fFp/FG6YE5jqVLYqQhcadKJNPV+Gt+XLsDTEgMV0+9/XakrYHrtNFlLKm9ajiB1Ka06eUdqFUnhL02/ny7C09i7tN5fzSUR0iQuKTSmNexeeumlbEKUNM1/apn5P//n/2Tjpmpz+eWXV64PmI5LY/rSkgHpYr3mOm5rIk3dn+o2vU/q2pdC9f/+7/9m67Gl8V4V0nivNI1/Oj5NGJJCaGqZTC1RKWxdf/312QQ1a0tahiKdC+l7kpbHSOvqpe6LVVtNk1TGFKhPOOGEbAmFFKbScRXnWH21+qZJT5K0nEEKlinYpfGiaSxhWuYh1WF6r3Q+pPBf25jF+q77FBjTz0ZaIzG9b/pDRQq36Q8Chx56aL18boCiKvb0ngD8/9P7V9zSkgBpevoDDzwwW46g6jIFdS2h8MwzzxSOPPLIQpcuXbLnp68nnHBC4e233672vIcffrjQq1evQrNmzapNVZ+myd9hhx1qLV9dSyjcc889heHDhxc23XTTbIr/ww47rPD++++v8Pw0XX9abiFN47/HHnsUXnnllRVeM1mwYEHhwgsvLHTv3r3QvHnzrA7+8z//s9ryCDWXDEheffXVwsCBAwsbbrhhoXXr1oX99tuvMG7cuFrruOa0+XVN5V+b+++/v7D99ttnnyPV4QMPPJAteVB1Gv8KN998c2HnnXfO6iUt59C7d+/Ceeedly3vsDLp9TbYYIMVttf1/Unvneq96hIKP/7xj7MlB9J7p/oeP358rfX9z3/+M3tuOm6TTTbJnpc+Y6qPCRMmfOV71/zstS1/8OWXXxbOPvvs7PXTEhBVz9m03EdagiF9z9q3b1/43ve+V5g0aVKty3zUZ92n8yX9bJSVlWWvl87fww8/PDsvAfKgSfqnuDETACgVqTV26NCh2WQ/abZVABofIQ8A1lELFy6sNkFJGpP3jW98IxvX9vbbbxe1bACsPmPyAGAddfTRR2frBqZJR9KkJmmsZBoTWtcSBAA0DkIeAKyj0kQov/3tb7NQl1rvevXqlS0hcNxxxxW7aACsAd01AQAAcsQ6eQAAADki5AEAAORI7sfkLV++PD766KNs0d/6WtgVAACgoaWRdvPmzYsuXbpE06ZN192QlwJe165di10MAACAevHBBx/EFltsse6GvNSCV1ERbdq0KXZxAAAAVkt5eXnWgFWRcdbZkFfRRTMFPCEPAABo7L5qGJqJVwAAAHJEyAMAAMgRIQ8AACBHhDwAAIAcEfIAAAByRMgDAADIESEPAAAgR4Q8AACAHBHyAAAAckTIAwAAyBEhDwAAIEeEPAAAgBwpmZB31VVXRZMmTeKcc86p3LZo0aI488wzY+ONN44NN9wwBg0aFB9//HFRywkAAFDKSiLkvfzyy/Gb3/wm+vTpU2370KFD49FHH4377rsvnn/++fjoo4/i6KOPLlo5AQAASl3RQ94XX3wRJ510Utxyyy3Rvn37yu1z586NW2+9Na655prYf//9Y+edd47Ro0fHuHHjYsKECUUtMwAAQKlqVuwCpO6Yhx12WAwYMCAuv/zyyu0TJ06MpUuXZtsr9OzZM8rKymL8+PGx22671fp6ixcvzm4VysvL1/InyJcZM2bE7Nmzo5R07Ngx+74DAAAlHvLGjBkTr776atZds6ZZs2ZFixYtol27dtW2b7bZZtm+uowcOTJGjBixVsq7LgS8nj23j4ULF0QpadWqdUyZMlnQAwCAUg55H3zwQfzoRz+Kp556KtZff/16e93hw4fHsGHDqrXkde3atd5eP89SC14KeP1OvSTadN4ySkH5zPfixdtGZGUT8gAAoIRDXuqO+cknn8Q3v/nNym3Lli2LF154IX7961/HE088EUuWLIk5c+ZUa81Ls2t26tSpztdt2bJldmP1pYDXoaxHsYsBAAA0ppB3wAEHxBtvvFFt2ymnnJKNuzv//POz1rfmzZvHM888ky2dkEydOjXrUti/f/8ilRoAAKC0FS3kbbTRRrHjjjtW27bBBhtka+JVbD/ttNOyrpcdOnSINm3axNlnn50FvLomXQEAAFjXFX12zZW59tpro2nTpllLXpoxc+DAgXHDDTcUu1gAAAAlq6RC3tixY6s9ThOyjBo1KrsBAADQCBZDBwAAoP4IeQAAADki5AEAAOSIkAcAAJAjQh4AAECOCHkAAAA5IuQBAADkiJAHAACQI0IeAABAjgh5AAAAOSLkAQAA5IiQBwAAkCNCHgAAQI4IeQAAADki5AEAAOSIkAcAAJAjQh4AAECOCHkAAAA5IuQBAADkiJAHAACQI0IeAABAjgh5AAAAOSLkAQAA5IiQBwAAkCNCHgAAQI4IeQAAADki5AEAAOSIkAcAAJAjQh4AAECOCHkAAAA5IuQBAADkSLNiF2BdNWPGjJg9e3aUksmTJxe7CAAAwBoS8ooU8Hr23D4WLlwQpWjp4iXFLgIAALCahLwiSC14KeD1O/WSaNN5yygVM98YH5MeuTm+/PLLYhcFAABYTUJeEaWA16GsR5SK8pnvFbsIAADAGjLxCgAAQI4IeQAAADlS1JB34403Rp8+faJNmzbZrX///vHYY49V7t93332jSZMm1W7f//73i1lkAACAklbUMXlbbLFFXHXVVbHttttGoVCIO+64I4488sj4+9//HjvssEN2zOmnnx6XXXZZ5XNat25dxBIDAACUtqKGvCOOOKLa4yuuuCJr3ZswYUJlyEuhrlOnTkUqIQAAQONSMmPyli1bFmPGjIn58+dn3TYr3HXXXdGxY8fYcccdY/jw4bFgwcrXllu8eHGUl5dXuwEAAKwrir6EwhtvvJGFukWLFsWGG24YDz74YPTq1Svbd+KJJ0a3bt2iS5cu8frrr8f5558fU6dOjQceeKDO1xs5cmSMGDGiAT8BAABA6Sh6yOvRo0e89tprMXfu3PjDH/4QQ4YMieeffz4LemeccUblcb17947OnTvHAQccENOnT4+tt9661tdLrX3Dhg2rfJxa8rp27dognwUAACDW9ZDXokWL2GabbbL7O++8c7z88stx/fXXx29+85sVju3Xr1/2ddq0aXWGvJYtW2Y3AACAdVHJjMmrsHz58mxcXW1Si1+SWvQAAAAosZa81LXykEMOibKyspg3b17cfffdMXbs2HjiiSeyLpnp8aGHHhobb7xxNiZv6NChsffee2dr6wEAAFBiIe+TTz6J7373uzFz5sxo27ZtFt5SwDvwwAPjgw8+iKeffjquu+66bMbNNK5u0KBBcdFFFxWzyAAAACWtqCHv1ltvrXNfCnVpAhYAAAAa8Zg8AAAAVp+QBwAAkCNCHgAAQI4IeQAAADki5AEAAOSIkAcAAJAjQh4AAECOCHkAAAA5IuQBAADkiJAHAACQI0IeAABAjgh5AAAAOSLkAQAA5IiQBwAAkCNCHgAAQI4IeQAAADki5AEAAOSIkAcAAJAjQh4AAECOCHkAAAA5IuQBAADkiJAHAACQI0IeAABAjgh5AAAAOSLkAQAA5IiQBwAAkCNCHgAAQI4IeQAAADki5AEAAOSIkAcAAJAjQh4AAECOCHkAAAA5IuQBAADkiJAHAACQI0IeAABAjgh5AAAAOSLkAQAA5EhRQ96NN94Yffr0iTZt2mS3/v37x2OPPVa5f9GiRXHmmWfGxhtvHBtuuGEMGjQoPv7442IWGQAAoKQVNeRtscUWcdVVV8XEiRPjlVdeif333z+OPPLIePPNN7P9Q4cOjUcffTTuu+++eP755+Ojjz6Ko48+uphFBgAAKGnNivnmRxxxRLXHV1xxRda6N2HChCwA3nrrrXH33Xdn4S8ZPXp0bL/99tn+3XbbrUilBgAAKF0lMyZv2bJlMWbMmJg/f37WbTO17i1dujQGDBhQeUzPnj2jrKwsxo8fX+frLF68OMrLy6vdAAAA1hVFD3lvvPFGNt6uZcuW8f3vfz8efPDB6NWrV8yaNStatGgR7dq1q3b8Zpttlu2ry8iRI6Nt27aVt65duzbApwAAACgNRQ95PXr0iNdeey1efPHF+MEPfhBDhgyJt956a7Vfb/jw4TF37tzK2wcffFCv5QUAAChlRR2Tl6TWum222Sa7v/POO8fLL78c119/fRx33HGxZMmSmDNnTrXWvDS7ZqdOnep8vdQimG4AAADroqK35NW0fPnybFxdCnzNmzePZ555pnLf1KlTY8aMGdmYPQAAAEqsJS91rTzkkEOyyVTmzZuXzaQ5duzYeOKJJ7LxdKeddloMGzYsOnTokK2jd/bZZ2cBz8yaAAAAJRjyPvnkk/jud78bM2fOzEJdWhg9BbwDDzww23/ttddG06ZNs0XQU+vewIED44YbbihmkQEAAEpaUUNeWgdvZdZff/0YNWpUdgMAAKARjskDAABg9Ql5AAAAOSLkAQAA5IiQBwAAkCNCHgAAQI4IeQAAADki5AEAAOSIkAcAAJAjQh4AAECOCHkAAAA5IuQBAADkiJAHAACQI0IeAABAjgh5AAAAOSLkAQAA5IiQBwAAkCNCHgAAQI4IeQAAADki5AEAAOSIkAcAAJAjQh4AAECOCHkAAAA5IuQBAADkiJAHAACQI0IeAABAjgh5AAAAOSLkAQAA5IiQBwAAkCNCHgAAQI4IeQAAADki5AEAAOSIkAcAAJAjQh4AAECOCHkAAAA5IuQBAADkiJAHAACQI0IeAABAjhQ15I0cOTK+9a1vxUYbbRSbbrppHHXUUTF16tRqx+y7777RpEmTarfvf//7RSszAABAKStqyHv++efjzDPPjAkTJsRTTz0VS5cujYMOOijmz59f7bjTTz89Zs6cWXn7+c9/XrQyAwAAlLJmxXzzxx9/vNrj22+/PWvRmzhxYuy9996V21u3bh2dOnUqQgkBAAAal5Iakzd37tzsa4cOHaptv+uuu6Jjx46x4447xvDhw2PBggV1vsbixYujvLy82g0AAGBdUdSWvKqWL18e55xzTuyxxx5ZmKtw4oknRrdu3aJLly7x+uuvx/nnn5+N23vggQfqHOc3YsSIBiw5AABA6SiZkJfG5k2aNCn++te/Vtt+xhlnVN7v3bt3dO7cOQ444ICYPn16bL311iu8TmrpGzZsWOXj1JLXtWvXtVx6AACA0lASIe+ss86KP/7xj/HCCy/EFltssdJj+/Xrl32dNm1arSGvZcuW2Q0AAGBdVNSQVygU4uyzz44HH3wwxo4dG927d//K57z22mvZ19SiBwAAQAmFvNRF8+67746HH344Wytv1qxZ2fa2bdtGq1atsi6Zaf+hhx4aG2+8cTYmb+jQodnMm3369Clm0QEAAEpSUUPejTfeWLngeVWjR4+Ok08+OVq0aBFPP/10XHfdddnaeWls3aBBg+Kiiy4qUokBAABKW9G7a65MCnVpwXQAAAAa4Tp5AAAArBkhDwAAIEeEPAAAgHVxTF7VBca/yjXXXLO65QEAAKAhQt7f//73ao9fffXV+PLLL6NHjx7Z47fffjvWW2+92HnnndekPAAAADREyHvuueeqtdSlde3uuOOOaN++fbbt888/j1NOOSX22muvNSkPAAAADT0m7+qrr46RI0dWBrwk3b/88suzfQAAADSikFdeXh6ffvrpCtvTtnnz5tVHuQAAAGiokPftb38765r5wAMPxIcffpjd7r///jjttNPi6KOPXp2XBAAAoCHH5FV10003xbnnnhsnnnhiLF269P+9ULNmWcj7xS9+UR/lAgAAoKFCXuvWreOGG27IAt306dOzbVtvvXVssMEGq/NyAAAAFDPkVUihrk+fPvVVFgAAAIoV8l555ZW49957Y8aMGbFkyZJq+9JYPQAAABrJxCtjxoyJ3XffPSZPnhwPPvhgNi7vzTffjGeffTbatm1b/6UEAABg7YW8K6+8Mq699tp49NFHo0WLFnH99dfHlClT4thjj42ysrLVeUkAAACKFfLSZCuHHXZYdj+FvPnz50eTJk1i6NChcfPNN9dHuQAAAGiokNe+ffvKRc8333zzmDRpUnZ/zpw5sWDBgtV5SQAAAIo18cree+8dTz31VPTu3TuOOeaY+NGPfpSNx0vbDjjggPooFwAAAA0V8n7961/HokWLsvsXXnhhNG/ePMaNGxeDBg2Kiy66aHVeEgAAgGKFvA4dOlTeb9q0aVxwwQX1URYAAAAaKuSVl5ev8ou2adNmdcsDAABAQ4S8du3aZTNoroply5atSZkAAABY2yHvueeeq7z/3nvvZV00Tz755Ojfv3+2bfz48XHHHXfEyJEjV7csAAAANFTI22effSrvX3bZZXHNNdfECSecULntP/7jP7LZNtM6eUOGDFnTcgEAANBQ6+SlVrtddtllhe1p20svvbQ6LwkAAECxQl7Xrl3jlltuWWH7b3/722wfAAAAjWgJhWuvvTZbE++xxx6Lfv36ZdtSC94777wT999/f32XEQAAgLXZknfooYfG22+/HUcccUT8+9//zm7pftqW9gEAANCIWvKS1C3zyiuvrN/SAAAA0DAh7/XXX48dd9wxmjZtmt1fmT59+qxZqQAAAFi7Ia9v374xa9as2HTTTbP7aWH0QqGwwnFpu8XQAQAASjzkvfvuu7HJJptU3oeGNHny5Cg1HTt2jLKysmIXAwAAVi/kdevWrfL++++/H7vvvns0a1b96V9++WWMGzeu2rGwJhbO/Sy1D8fgwYOj1LRq1TqmTJks6AEA0PgnXtlvv/1i5syZWdfNqubOnZvt012T+rJ0wbyIKETfE8+PTbr3jFJRPvO9ePG2ETF79mwhDwCAxh/y0li8NPaups8++yw22GCD+igXVLPhpmXRoaxHsYsBAAD5CnlHH3109jUFvJNPPjlatmxZuS+13qVZN1M3TgAAABpByGvbtm1lS95GG20UrVq1qtzXokWL2G233eL000+v/1ICAABQ/yFv9OjR2dctt9wyzj333DXumjly5Mh44IEHYsqUKVlgTK2AP/vZz6JHj/+/W96iRYvixz/+cYwZMyYWL14cAwcOjBtuuCE222yzNXpvAACAPGq6Ok+65JJL6mXs3fPPPx9nnnlmTJgwIZ566qlYunRpHHTQQTF//vzKY4YOHRqPPvpo3HfffdnxH330UWW3UQAAAOph4pWPP/44a8l75pln4pNPPllhUfRVnV3z8ccfr/b49ttvz2bsnDhxYuy9997ZbJ233npr3H333bH//vtXtiZuv/32WTBM3UMBAABYw5CXJl2ZMWNGXHzxxdG5c+daZ9pcHSnUJR06dMi+prCXWvcGDBhQeUzPnj2zKevHjx9fa8hLXTrTrUJ5eXm9lA0awyLtFmgHAGC1Qt5f//rX+Mtf/hJ9+/att4IsX748zjnnnNhjjz1ixx13zLbNmjUrm9ClXbt21Y5N4/HSvrrG+Y0YMaLeygWNaZF2C7QDALBaIa9r164rdNFcU2ls3qRJk7IAuSaGDx8ew4YNq9aSl8oLeV+k3QLtAACsdsi77rrr4oILLojf/OY32Uyba+qss86KP/7xj/HCCy/EFltsUbm9U6dOsWTJkpgzZ0611rw0JjDtq01au6/q+n2wNlmkHQCAXIS84447LhYsWBBbb711tG7dOpo3b15t/7///e9Vep3UGnj22WfHgw8+GGPHjo3u3btX27/zzjtnr50meBk0aFC2berUqdl4wP79+69O0QEAAHJttVvy6quLZpo58+GHH84WV68YZ5cWXU/r5qWvp512Wtb9Mk3G0qZNmywUpoBnZk0AAIB6CnlDhgyJ+nDjjTdmX/fdd99q29MyCWkGz+Taa6+Npk2bZi15VRdDBwAAoJ5CXlWLFi3Kxs1VlVrcVsWqTN6y/vrrx6hRo7IbAAAAK9c0VsP8+fOzyVLSwuUbbLBBtG/fvtoNAACARhTyzjvvvHj22Wez7pZpJsvf/va32dp0Xbp0iTvvvLP+SwkAAMDa66756KOPZmEujaU75ZRTYq+99optttkmunXrFnfddVecdNJJq/OyAAAAFKMlLy2RsNVWW1WOv6tYMmHPPffM1roDAACgEYW8FPDefffd7H7Pnj3j3nvvrWzhq7poOQAAAI0g5KUumv/4xz+y+xdccEE282WaBfOcc86J//7v/67vMgIAALA2x+QNHTq08v6AAQNiypQpMXHixNh2222jd+/eq/OSAAAANHRLXppRs1evXlFeXl5te5pw5YADDojjjz8+/vKXv9RHuQAAAFjbIe+6666L008/vdbFztu2bRvf+9734pprrlmdcgAAANDQIS+Nwzv44IPr3H/QQQdl3TYBAABoBCHv448/jubNm9e5v1mzZvHpp5/WR7kAAABY2yFv8803j0mTJtW5//XXX4/OnTuvTjkAAABo6JB36KGHxsUXXxyLFi1aYd/ChQvjkksuicMPP7w+ygUAAMDaXkLhoosuigceeCC22267OOuss6JHjx7Z9rSEQlorb9myZXHhhReuTjkAAABo6JC32Wabxbhx4+IHP/hBDB8+PAqFQra9SZMmMXDgwCzopWMAAABoJIuhpzXx/vznP8fnn38e06ZNy4JeWgS9ffv2a6eEAAAArL2QVyGFum9961ur+3QAAACKPfEKAAAApU3IAwAAyBEhDwAAIEeEPAAAgBwR8gAAAHJEyAMAAMgRIQ8AACBHhDwAAIAcEfIAAAByRMgDAADIESEPAAAgR4Q8AACAHBHyAAAAckTIAwAAyBEhDwAAIEeEPAAAgBwR8gAAAHJEyAMAAMgRIQ8AACBHhDwAAIAcKWrIe+GFF+KII46ILl26RJMmTeKhhx6qtv/kk0/Otle9HXzwwUUrLwAAQKkrasibP39+7LTTTjFq1Kg6j0mhbubMmZW3e+65p0HLCAAA0Jg0K+abH3LIIdltZVq2bBmdOnVqsDIBAAA0ZkUNeati7Nixsemmm0b79u1j//33j8svvzw23njjOo9fvHhxdqtQXl7eQCWF0jB58uQoJR07doyysrJiFwMAYJ1R0iEvddU8+uijo3v37jF9+vT4n//5n6zlb/z48bHeeuvV+pyRI0fGiBEjGrysUGwL534WEU1i8ODBUUpatWodU6ZMFvQAABpISYe8448/vvJ+7969o0+fPrH11ltnrXsHHHBArc8ZPnx4DBs2rFpLXteuXRukvFBMSxfMi4hC9D3x/Nike88oBeUz34sXbxsRs2fPFvIAABpISYe8mrbaaqus69e0adPqDHlpDF+6wbpqw03LokNZj2IXAwCAImlU6+R9+OGH8dlnn0Xnzp2LXRQAAICSVNSWvC+++CJrlavw7rvvxmuvvRYdOnTIbmls3aBBg7LZNdOYvPPOOy+22WabGDhwYDGLDQAAULKKGvJeeeWV2G+//SofV4ylGzJkSNx4443x+uuvxx133BFz5szJFkw/6KCD4qc//anumAAAAKUY8vbdd98oFAp17n/iiScatDwAAACNXaMakwcAAMDKCXkAAAA5IuQBAADkiJAHAACQI0IeAABAjgh5AAAAOSLkAQAA5IiQBwAAkCNCHgAAQI4IeQAAADki5AEAAOSIkAcAAJAjQh4AAECOCHkAAAA5IuQBAADkiJAHAACQI0IeAABAjgh5AAAAOSLkAQAA5IiQBwAAkCNCHgAAQI40K3YBAIphxowZMXv27CglHTt2jLKysmIXAwBo5IQ8YJ0MeD17bh8LFy6IUtKqVeuYMmWyoAcArBEhD1jnpBa8FPD6nXpJtOm8ZZSC8pnvxYu3jcjKJuQBAGtCyAPWWSngdSjrUexiAADUKxOvAAAA5IiQBwAAkCNCHgAAQI4IeQAAADki5AEAAOSIkAcAAJAjQh4AAECOCHkAAAA5IuQBAADkiJAHAACQI0IeAABAjgh5AAAAOVLUkPfCCy/EEUccEV26dIkmTZrEQw89VG1/oVCIn/zkJ9G5c+do1apVDBgwIN55552ilRcAAKDUFTXkzZ8/P3baaacYNWpUrft//vOfx69+9au46aab4sUXX4wNNtggBg4cGIsWLWrwsgIAADQGzYr55occckh2q01qxbvuuuvioosuiiOPPDLbduedd8Zmm22Wtfgdf/zxDVxaAACA0leyY/LefffdmDVrVtZFs0Lbtm2jX79+MX78+KKWDQAAoFQVtSVvZVLAS1LLXVXpccW+2ixevDi7VSgvL1+LpQQAACgtJduSt7pGjhyZtfhV3Lp27VrsIgEAADSYkg15nTp1yr5+/PHH1banxxX7ajN8+PCYO3du5e2DDz5Y62UFAAAoFSUb8rp3756FuWeeeaZa18s0y2b//v3rfF7Lli2jTZs21W4AAADriqKOyfviiy9i2rRp1SZbee2116JDhw5RVlYW55xzTlx++eWx7bbbZqHv4osvztbUO+qoo4pZbAAAgJJV1JD3yiuvxH777Vf5eNiwYdnXIUOGxO233x7nnXdetpbeGWecEXPmzIk999wzHn/88Vh//fWLWGoAAIDSVdSQt++++2br4dWlSZMmcdlll2U3AAAAGvGYPAAAAL4+IQ8AACBHhDwAAIAcEfIAAAByRMgDAADIESEPAAAgR4Q8AACAHBHyAAAAckTIAwAAyBEhDwAAIEeEPAAAgBwR8gAAAHJEyAMAAMgRIQ8AACBHhDwAAIAcEfIAAAByRMgDAADIESEPAAAgR4Q8AACAHBHyAAAAckTIAwAAyJFmxS4AkH+TJ0+OUlJq5Sn1snXs2DHKysqilMyYMSNmz54dpaQU6wmAdZOQB6w1C+d+FhFNYvDgwVGKli5eEqWilOuqVavWMWXK5JIJMCng9ey5fSxcuCBKSanVEwDrLiEPWGuWLpgXEYXoe+L5sUn3nlEqZr4xPiY9cnN8+eWXUSpKta7KZ74XL942Ims1K5XwksqSAl6/Uy+JNp23jFJQivUEwLpLyAPWug03LYsOZT2iVKQL8lJVanVVylLAU1cAsCITrwAAAOSIkAcAAJAjQh4AAECOCHkAAAA5IuQBAADkiJAHAACQI0IeAABAjgh5AAAAOSLkAQAA5IiQBwAAkCNCHgAAQI4IeQAAADlS0iHv0ksvjSZNmlS79ezZs9jFAgAAKFnNosTtsMMO8fTTT1c+btas5IsMAABQNCWfmFKo69SpU7GLAQAA0CiUdHfN5J133okuXbrEVlttFSeddFLMmDGj2EUCAAAoWSXdktevX7+4/fbbo0ePHjFz5swYMWJE7LXXXjFp0qTYaKONan3O4sWLs1uF8vLyBiwxQD5Nnjw5SkUplQUASlFJh7xDDjmk8n6fPn2y0NetW7e4995747TTTqv1OSNHjszCIABrbuHczyKiSQwePDhKzdLFS4pdBAAoSSUd8mpq165dbLfddjFt2rQ6jxk+fHgMGzasWkte165dG6iEAPmydMG8iChE3xPPj026l8bsxjPfGB+THrk5vvzyy2IXBQBKUqMKeV988UVMnz49vvOd79R5TMuWLbMbAPVnw03LokNZjygF5TPfK3YRAKCklfTEK+eee248//zz8d5778W4cePi29/+dqy33npxwgknFLtoAAAAJamkW/I+/PDDLNB99tlnsckmm8See+4ZEyZMyO4DAADQyELemDFjil0EAACARqWku2sCAADw9Qh5AAAAOSLkAQAA5IiQBwAAkCNCHgAAQI4IeQAAADki5AEAAOSIkAcAAJAjQh4AAECOCHkAAAA5IuQBAADkiJAHAACQI82KXQAAyIvJkydHqenYsWOUlZUVuxgANCAhDwDW0MK5n0VEkxg8eHCUmlatWseUKZMFPYB1iJAHAGto6YJ5EVGIvieeH5t07xmlonzme/HibSNi9uzZQh7AOkTIA4B6suGmZdGhrEexiwHAOs7EKwAAADki5AEAAOSIkAcAAJAjQh4AAECOCHkAAAA5YnZNAMi5UlukvVQXaJ8xY0a23EQpKdW6gnXh568x/wwKeQCQU6W6SHspLtCeLjB79tw+Fi5cEKWkFOsK1pWfv8b8MyjkAUBOleIi7aW6QHsqT7rA7HfqJdGm85ZRCkq1rmBd+Plr7D+DQh4A5JxF2lddusBUV1Acfv7qj4lXAAAAckTIAwAAyBEhDwAAIEeEPAAAgBwR8gAAAHJEyAMAAMgRSygAAA1u8uTJUUpKrTylXrbFixdHy5Yto5R07Nix5NYyS4t8pzXWSk0p1hX1S8gDABrMwrmfRUSTGDx4cJSipYuXRKko6bpq0iSiUIhS0qpV65gyZXLJhJcU8Hr23D5b5LvUlFpdUf+EPACgwSxdMC8iCtH3xPNjk+49o1TMfGN8THrk5vjyyy+jVJR6XZVSucpnvhcv3jYiazUrleCSypICXr9TL8kW+S4VpVhX1D8hDwBocBtuWhYdynpEKV34lqpSratSK1epSgFPPdHQTLwCAACQI0IeAABAjjSKkDdq1KjYcsstY/31149+/frFSy+9VOwiAQAAlKSSD3m///3vY9iwYXHJJZfEq6++GjvttFMMHDgwPvnkk2IXDQAAoOSUfMi75ppr4vTTT49TTjklevXqFTfddFO0bt06brvttmIXDQAAoOSUdMhbsmRJTJw4MQYMGFC5rWnTptnj8ePHF7VsAAAApaikl1BI63csW7YsNttss2rb0+MpU6bU+pzFixdntwpz587NvpaXl0ep+OKLL7Kv/35/any5eGGUivKZ72df5/7rnWjerEmUglIsU6mWS5kad7lKsUylWi5latzlKsUylWq5SrFMpVqu8lkzsq+pcaDiOqvYpk6dWprXe+rqa9dVqqdSyRIV5SgUCis9rknhq44ooo8++ig233zzGDduXPTv379y+3nnnRfPP/98vPjiiys859JLL40RI0Y0cEkBAAAaxgcffBBbbLFF42zJ69ixY6y33nrx8ccfV9ueHnfq1KnW5wwfPjybqKXC8uXL49///ndsvPHG0aRJify1qbw8unbtmn1z2rRpU+zirDPUe8NT58Wh3hueOi8O9V4c6r3hqfPiKC/Bek/tc/PmzYsuXbqs9LiSDnktWrSInXfeOZ555pk46qijKkNbenzWWWfV+pyWLVtmt6ratWsXpSidLKVywqxL1HvDU+fFod4bnjovDvVeHOq94anz4mhTYvXetm3brzympENeklrlhgwZErvsskvsuuuucd1118X8+fOz2TYBAABoZCHvuOOOi08//TR+8pOfxKxZs6Jv377x+OOPrzAZCwAAAI0g5CWpa2Zd3TMbo9SdNC3uXrNbKWuXem946rw41HvDU+fFod6LQ703PHVeHC0bcb2X9OyaAAAA5GgxdAAAAL4eIQ8AACBHhDwAAIAcEfLW0KWXXpotsl711rNnzzqPv/3221c4fv311692TBommWYT7dy5c7Rq1SoGDBgQ77zzTgN8mvzW+7777rvC8el22GGHVR5z8sknr7D/4IMPbqBP1Dj861//isGDB8fGG2+cnZu9e/eOV155ZaXPGTt2bHzzm9/MBi1vs8022c9ATaNGjYott9wy+1no169fvPTSS2vxU+S/3h944IE48MADY5NNNsnW9enfv3888cQTa/QztK75unWezvPafsekWaGrcq7Xb73X9ns73XbYYYfKY5zrdUvnYm31d+aZZ9b5nPvuuy+rv3QOp+/Pn//852r7XcPUf73fcsstsddee0X79u2zW6rTmr87XMPUb53fnoPrdSGvHqT/TGbOnFl5++tf/7rS49NFV9Xj33///Wr7f/7zn8evfvWruOmmm+LFF1+MDTbYIAYOHBiLFi1ay58kv/WeLnqrHjtp0qRYb7314phjjql2XPqFWPW4e+65pwE+SePw+eefxx577BHNmzePxx57LN566624+uqrs/9w6vLuu+9mQXq//faL1157Lc4555z4r//6r2qB4/e//322HmaaverVV1+NnXbaKTvfP/nkkwb6ZPmr9xdeeCELeenia+LEiVn9H3HEEfH3v/99jX53rStWp84rTJ06tVqdbrrpppX7nOv1X+/XX399tfr+4IMPokOHDiv8bneu1+7ll1+uVi9PPfVUtr1m/VUYN25cnHDCCXHaaadlv0+OOuqo7Jb+T63gGqb+6z39ESnV+3PPPRfjx4+Prl27xkEHHZT9UaQq1zD1V+e5uF5Ps2uy+i655JLCTjvttMrHjx49utC2bds69y9fvrzQqVOnwi9+8YvKbXPmzCm0bNmycM8996xxedfVeq/p2muvLWy00UaFL774onLbkCFDCkceeWQ9lTB/zj///MKee+75tZ5z3nnnFXbYYYdq24477rjCwIEDKx/vuuuuhTPPPLPy8bJlywpdunQpjBw5sh5KvW7We2169epVGDFiRL39DOXZ6tT5c889l2aqLnz++ed1HuNcX/vn+oMPPlho0qRJ4b333qvc5lxfdT/60Y8KW2+9dXYtUptjjz22cNhhh1Xb1q9fv8L3vve97L5rmLVT7zV9+eWX2TXMHXfcUbnNNUz91vnoHFyva8mrB6lptkuXLrHVVlvFSSedFDNmzFjp8V988UV069Yt+0vMkUceGW+++Wa1lo/UvSc1+VZo27Zt1q0n/fWG1a/3qm699dY4/vjjs7+61PxrWfrLe48ePeIHP/hBfPbZZ2uh5I3TI488Ervsskv2V69UR9/4xjeyLiQrk87Zqudykv7KVXEuL1myJGtpqnpM06ZNs8fO99Wv95qWL18e8+bNy1o46utnKM/WpM779u2bdd1JLal/+9vfKrc71xvmXE+/21Odpv9jq3Kuf7V0jv7ud7+LU089Neuatjq/013DrJ16r2nBggWxdOnSFX6nu4ap3zr/opFfrwt5ayh9M1O/3ccffzxuvPHG7Jue+k2nC6rapB+82267LR5++OHsBEsXX7vvvnt8+OGH2f6K8RubbbZZteelxzXHdqzLvm69V5X6saeuJanbYM1uDnfeeWc888wz8bOf/Syef/75OOSQQ2LZsmVr8ZM0Hv/85z+zut52222z7pbpP5Af/vCHcccdd9T5nHTO1nYul5eXx8KFC2P27NlZ/Trf67fea/rlL3+Z/Wd17LHH1svPUN6tTp2nYJe67Nx///3ZLV0UpLHAqVtm4lxf++f6Rx99lHXzrPm73bm+ah566KGYM2dONrbr6/5OrziHXcOsnXqv6fzzz8/+aFE1YLiGqd8675GH6/ViNyXmTeqq06ZNm8Jvf/vbVTp+yZIlWXPxRRddlD3+29/+lnX5+eijj6odd8wxx2TdJFjzej/jjDMKvXv3/srjpk+fnn0vnn766XoqZePWvHnzQv/+/attO/vsswu77bZbnc/ZdtttC1deeWW1bX/605+yel2wYEHhX//6V3Z/3Lhx1Y757//+76xrG6tX71XdddddhdatWxeeeuqpev3dlWdrWucV9t5778LgwYOz+871tV/v6XfNxhtvXFi8ePFKj3Ou1+6ggw4qHH744V/5Pbr77rurbRs1alRh0003ze67hlk79V5V6t7dvn37wj/+8Y+VHucapv7qvLFer2vJq2ft2rWL7bbbLqZNm7ZKx6cB5qlLSsXxnTp1yr5+/PHH1Y5Ljyv2sfr1Pn/+/BgzZkw2aPyrpG49HTt2XOXvZd6llopevXpV27b99tuvtNtTOmdrO5fTYOY0E1Wq3zQBjvO9fuu9QjrXU6vGvffeu0IXqzX93ZVna1LnVe26666V9elcX7v1nma5S391/853vhMtWrRY6bHO9RWlCSWefvrpFVpBV/V3esU57Bpm7dR71V4ZV111VTz55JPRp0+flR7rGqZ+6rwxX68LefUsdYmaPn169p/VqkjN6G+88Ubl8d27d89OjtTcXiF1bUuz9qRp0Fmzek9TPy9evDibovurpCb51J99Vb+XeZdmvUszB1b19ttvrzD2pap0zlY9l5M0o1XFuZwuxnbeeedqx6QuEemx83316z1Js6qdcsop2deqS4XU1++uPFvdOq8pzShbUZ/O9bVb76lrWrr4WpU/4DnXVzR69OhsLNdX/a74qt/prmHWTr1XzOT405/+NOt2nMaufhXXMGte543+er3YTYmN3Y9//OPC2LFjC++++27WdDtgwIBCx44dC5988km2/zvf+U7hggsuqDw+zW73xBNPZM3oEydOLBx//PGF9ddfv/Dmm29WHnPVVVcV2rVrV3j44YcLr7/+ejZbUvfu3QsLFy4symfMQ71XSDO3pdkda5o3b17h3HPPLYwfPz57zdS94Zvf/GbW3XDRokUN8plK3UsvvVRo1qxZ4Yorrii88847ld0Af/e731Uek+o81X2Ff/7zn9kxqUva5MmTs2496623XuHxxx+vPGbMmDHZbFS333574a233sq606bzf9asWQ3+GfNS7+mY9JxU3zNnzqy8pZm/VvVnaF22OnWeZux96KGHsuPfeOONbOa2pk2bVusq5Vyv/3qvkLrFplkea+NcX7k0y2tZWVk2u2lNNf8vTfWXvke//OUvs9/paebS1IUznfMVXMPUf72nOm3RokXhD3/4Q7Xf6enaJXENU/91PiIH1+tC3hpKgaFz587ZD9/mm2+ePZ42bVrl/n322Seb1rbCOeeck51g6fjNNtuscOihhxZeffXVFaZlvfjii7P96YLggAMOKEydOrVBP1fe6j2ZMmVK1n/6ySefXOH10viw1Ed7k002yf7D6tatW+H000938VXDo48+Wthxxx2z87Jnz56Fm2++udr+VOep7mtOLd+3b9/se7XVVltl0xLX9L//+7+VPxdpfNKECRPW+mfJc72n++lcr3mr+jPxVT9D67qvW+c/+9nPsvEa6SKgQ4cOhX333bfw7LPPrvC6zvX6/x2T/njRqlWrFY6t4FxfuXQhm34/1HadUdv/pffee29hu+22y+ozLZGTxllX5Rqm/us9XZPU9js9hezENUz91/k5Obheb5L+KXZrIgAAAPXDmDwAAIAcEfIAAAByRMgDAADIESEPAAAgR4Q8AACAHBHyAAAAckTIAwAAyBEhDwAAIEeEPABYiy699NLo27fvWnnt22+/Pdq1a7dWXhuAxkvIAyA3Tj755GjSpEl8//vfX2HfmWeeme1LxzSkc889N5555plqZTzqqKMatAwArFuEPABypWvXrjFmzJhYuHBh5bZFixbF3XffHWVlZQ1eng033DA23njjBn9fANZdQh4AufLNb34zC3oPPPBA5bZ0PwW8b3zjG5XbHn/88dhzzz2z7o4phB1++OExffr0aq81bty4rKvl+uuvH7vssks89NBDWWvga6+9lu0fO3Zs9ji11KX9rVu3jt133z2mTp1aa3fNdP+OO+6Ihx9+OHteuqXXqHidOXPmVD4vvUfa9t5771Xrnpk+R3qfb3/72/HZZ5+tpVoEoDET8gDInVNPPTVGjx5d+fi2226LU045pdox8+fPj2HDhsUrr7yShbSmTZtmwWn58uXZ/vLy8jjiiCOid+/e8eqrr8ZPf/rTOP/882t9vwsvvDCuvvrq7LWaNWuWvX9dXTePPfbYOPjgg2PmzJnZLYXCVfHiiy/GaaedFmeddVYWAPfbb7+4/PLLv0atALCuaFbsAgBAfRs8eHAMHz483n///ezx3/72t6wLZ2oxqzBo0KBqz0lBcJNNNom33nordtxxx6x7Z2pJu+WWW7KWvF69esW//vWvOP3001d4vyuuuCL22Wef7P4FF1wQhx12WNZFND2vZtfNVq1axeLFi6NTp05f6zNdf/31WTg877zzssfbbbdd1tKYWiQBoCoteQDkTgprKWil7o2pRS/d79ixY7Vj3nnnnTjhhBNiq622ijZt2sSWW26ZbZ8xY0b2NXW57NOnT7Wgtuuuu9b6fum4Cp07d86+fvLJJ/X6mSZPnhz9+vWrtq1///71+h4A5IOWPAByKXWZTF0bk1GjRq2wP3XF7NatW9ZS16VLl6ybZmrBW7Jkydd+r+bNm1feT61/SUW3z1WRuoomhUKhctvSpUu/djkAINGSB0Aupa6NKbClsDRw4MBq+9KEJaml7qKLLooDDjggtt9++/j888+rHdOjR4944403sq6VFV5++eU1LleLFi1i2bJlK7Q8JmmMXoWKyV0qpDKmcXlVTZgwYY3LA0D+CHkA5NJ6662XdXFMY+zS/arat2+fzah58803x7Rp0+LZZ5/NJmGp6sQTT8xa484444zsdZ544on45S9/Wa21bnWkbqGvv/56FjJnz56dhdBtttkmmxE0zb6ZupH+6U9/yiZyqeqHP/xhNv4ulSEd8+tf/9p4PABqJeQBkFtprF261dY9Mk3EMnHixKyL5tChQ+MXv/jFCs999NFHsxa1tARCmkHzJz/5Sbav5oQqX0eauCW1EqYlF1ILXpoUJnX3vOeee2LKlCnZ+L6f/exnK8ycudtuu2VdS9MELDvttFM8+eSTWUskANTUpFB1AAAAUKe77rorW4ph7ty52SyZAFCKTLwCAHW48847s9k3N9988/jHP/6RrZOX1rkT8AAoZUIeANRh1qxZWRfN9DUtjXDMMcdka+IBQCnTXRMAACBHTLwCAACQI0IeAABAjgh5AAAAOSLkAQAA5IiQBwAAkCNCHgAAQI4IeQAAADki5AEAAOSIkAcAABD58f8BLzVZc5qdVwwAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# ── Parte b) — Visualizaciones ───────────────────────────────────────────────\n", + "\n", + "# Gráfica 1: Histograma de magnitudes\n", + "# Crea figura\n", + "plt.figure(figsize=(9, 5))\n", + "\n", + "# Hint: sns.histplot(data=sismos, x='mag', bins=20)\n", + "\n", + "# TU CÓDIGO AQUÍ\n", + "# Crea histograma de magnitudes\n", + "sns.histplot(data=sismos, x='mag', bins=20)\n", + "\n", + "# Título de gráfica\n", + "plt.title(\"Distribución de magnitudes\")\n", + "\n", + "# Etiqueta eje X\n", + "plt.xlabel(\"Magnitud\")\n", + "\n", + "# Etiqueta eje Y\n", + "plt.ylabel(\"Cantidad\")\n", + "\n", + "# Ajusta elementos de la gráfica\n", + "plt.tight_layout()\n", + "\n", + "# Muestra la gráfica\n", + "plt.show()\n", + "\n", + "# Gráfica 2: Scatter profundidad vs magnitud coloreado por categoría\n", + "# Crea figura\n", + "plt.figure(figsize=(9, 5))\n", + "\n", + "# Hint: sns.scatterplot(data=sismos, x='mag', y='depth', hue='categoria', s=40, alpha=0.6)\n", + "\n", + "# TU CÓDIGO AQUÍ\n", + "# Crea scatterplot\n", + "sns.scatterplot(data=sismos, x='mag', y='depth', hue='categoria', s=40, alpha=0.6)\n", + "\n", + "# Título de gráfica\n", + "plt.title(\"Profundidad vs Magnitud\")\n", + "\n", + "# Etiqueta eje X\n", + "plt.xlabel(\"Magnitud\")\n", + "\n", + "# Etiqueta eje Y\n", + "plt.ylabel(\"Profundidad\")\n", + "\n", + "# Ajusta gráfica\n", + "plt.tight_layout()\n", + "\n", + "# Muestra gráfica\n", + "plt.show()\n", + "\n", + "# Gráfica 3: Barras — cantidad de sismos por tipo de escala (magType)\n", + "# Crea figura\n", + "plt.figure(figsize=(9, 5))\n", + "\n", + "# Hint: obtén los conteos con sismos['magType'].value_counts()\n", + "# luego grafica con .plot(kind='bar') o plt.bar() o sns.barplot()\n", + "\n", + "# TU CÓDIGO AQUÍ\n", + "# Cuenta tipos de escala\n", + "conteos = sismos['magType'].value_counts()\n", + "\n", + "# Genera gráfica de barras\n", + "conteos.plot(kind='bar')\n", + "\n", + "# Título de gráfica\n", + "plt.title(\"Cantidad de sismos por tipo de escala\")\n", + "\n", + "# Etiqueta eje X\n", + "plt.xlabel(\"Tipo de escala\")\n", + "\n", + "# Etiqueta eje Y\n", + "plt.ylabel(\"Cantidad\")\n", + "\n", + "# Ajusta gráfica\n", + "plt.tight_layout()\n", + "\n", + "# Muestra gráfica\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "interp-ej4", + "metadata": {}, + "source": [ + "#### Preguntas de interpretación — Ejercicio 4\n", + "\n", + "1. Según la función `analizar_sismos()`, completa:\n", + " - Magnitud media: ___ \n", + " - Magnitud máxima: ___ \n", + " - Tipo de escala más común (`magType`): ___ \n", + " - Grandes terremotos (mag ≥ 7.0): ___\n", + "\n", + "2. **Sobre el histograma (Gráfica 1):** \n", + " ¿La distribución de magnitudes es simétrica o sesgada?\n", + " ¿Hacia qué lado se inclina y por qué tiene sentido físicamente?\n", + "\n", + " *Tu respuesta:* ___\n", + "\n", + "3. **Sobre el scatter plot (Gráfica 2):** \n", + " ¿Observas alguna relación entre la profundidad y la magnitud?\n", + " ¿Los sismos más intensos tienden a ser superficiales o profundos en tu dataset?\n", + "\n", + " *Tu respuesta:* ___\n", + "\n", + "4. **Sobre las barras por `magType` (Gráfica 3):** \n", + " ¿Qué escala de magnitud es la más usada en tu dataset?\n", + " Investiga brevemente: ¿para qué tipo de sismos se usa esa escala?\n", + "\n", + " *Tu respuesta:* ___\n" + ] + }, + { + "cell_type": "markdown", + "id": "4e7c9c06", + "metadata": {}, + "source": [ + "---\n", + "## Ejercicio 5 — Programación Orientada a Objetos (25 pts)\n", + "\n", + "En el archivo `poo_sismos.py` encontrarás tres clases:\n", + "\n", + "- **`EventoSismico`** — clase base con atributos comunes: `lugar` y `fecha`\n", + "- **`Sismo`** — hereda de `EventoSismico`, agrega `magnitud`, `profundidad` y `tipo_escala`\n", + "- **`CatalogoSismos`** — colección de objetos `Sismo` con métodos de consulta\n", + "\n", + "**Paso 1:** Abre `poo_sismos.py` e implementa todos los métodos marcados con `# TU CÓDIGO AQUÍ`. \n", + "**Paso 2:** Regresa aquí y ejecuta las celdas siguientes en orden.\n", + "\n", + "| Parte | Tarea | Pts |\n", + "|---|---|:---:|\n", + "| a | 4 métodos de `Sismo`: `clasificar`, `clasificar_profundidad`, `es_peligroso`, `descripcion` | 10 |\n", + "| b | 3 métodos de `CatalogoSismos`: `el_mas_intenso`, `filtrar_por_categoria`, `resumen` | 10 |\n", + "| c | Ejecutar y responder las preguntas de interpretación | 5 |\n", + "| | **Subtotal** | **25** |" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "id": "74257b31", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sismo más intenso del catálogo:\n", + " None\n", + " Es peligroso? -> None\n", + "\n", + "Sismos de categoría 'Mayor' en los primeros 50: 0\n", + "\n", + "Resumen del catálogo\n", + "----------------------------------------\n", + "Nombre: Sismos USGS — Semestre 1 de 2024\n", + "Cantidad de sismos: 50\n", + "Sismo más intenso: None\n", + "----------------------------------------\n", + "\n", + "Verificación POO vs pandas (primeros 10 sismos):\n", + " mag pandas POO\n", + " -------------------------------------------------------\n", + " 5.60 Moderado Moderado-Fuerte\n", + " 6.10 Fuerte Fuerte\n", + " 5.70 Moderado Moderado-Fuerte\n", + " 7.20 Mayor Mayor\n", + " 5.90 Moderado Moderado-Fuerte\n", + " 5.60 Moderado Moderado-Fuerte\n", + " 6.30 Fuerte Fuerte\n", + " 6.00 Fuerte Fuerte\n", + " 5.50 Moderado Moderado-Fuerte\n", + " 5.80 Moderado Moderado-Fuerte\n" + ] + } + ], + "source": [ + "# Sismo más intenso del catálogo\n", + "\n", + "# Verifica si existen sismos en el catálogo\n", + "if len(catalogo._sismos) > 0:\n", + "\n", + " # Obtiene el sismo con mayor magnitud manualmente\n", + " mas_intenso = catalogo._sismos[0]\n", + "\n", + " # Recorre todos los sismos\n", + " for s in catalogo._sismos:\n", + "\n", + " # Compara magnitudes\n", + " if s.magnitud > mas_intenso.magnitud:\n", + "\n", + " # Actualiza el más intenso\n", + " mas_intenso = s\n", + "\n", + " # Imprime encabezado\n", + " print(\"Sismo más intenso del catálogo:\")\n", + "\n", + " # Imprime descripción\n", + " print(\" \", mas_intenso.descripcion())\n", + "\n", + " # Imprime si es peligroso\n", + " print(f\" Es peligroso? -> {mas_intenso.es_peligroso()}\\n\")\n", + "\n", + "else:\n", + "\n", + " # Mensaje si no hay datos\n", + " print(\"No hay sismos en el catálogo\")\n", + "\n", + "\n", + "# Filtrar por categoría\n", + "\n", + "# Lista para guardar resultados\n", + "mayores = []\n", + "\n", + "# Recorre todos los sismos\n", + "for s in catalogo._sismos:\n", + "\n", + " # Verifica categoría\n", + " if s.clasificar() == \"Mayor\":\n", + "\n", + " # Agrega coincidencia\n", + " mayores.append(s)\n", + "\n", + "# Imprime cantidad\n", + "print(f\"Sismos de categoría 'Mayor' en los primeros 50: {len(mayores)}\\n\")\n", + "\n", + "\n", + "# Resumen completo\n", + "\n", + "# Encabezado\n", + "print(\"Resumen del catálogo\")\n", + "\n", + "# Línea decorativa\n", + "print(\"-\" * 40)\n", + "\n", + "# Nombre\n", + "print(f\"Nombre: {catalogo.nombre}\")\n", + "\n", + "# Cantidad total\n", + "print(f\"Cantidad de sismos: {len(catalogo._sismos)}\")\n", + "\n", + "# Verifica que existan sismos\n", + "if len(catalogo._sismos) > 0:\n", + "\n", + " # Reutiliza el más intenso calculado antes\n", + " print(f\"Sismo más intenso: {mas_intenso.descripcion()}\")\n", + "\n", + "# Línea decorativa\n", + "print(\"-\" * 40)\n", + "\n", + "\n", + "# Verificación POO vs pandas\n", + "\n", + "print(\"\\nVerificación POO vs pandas (primeros 10 sismos):\")\n", + "\n", + "# Encabezados\n", + "print(f\" {'mag':>6} {'pandas':>20} {'POO':>20}\")\n", + "\n", + "# Línea decorativa\n", + "print(\" \" + \"-\" * 55)\n", + "\n", + "# Recorre primeros 10 registros\n", + "for indice, fila in sismos.head(10).iterrows():\n", + "\n", + " # Clasificación usando pandas\n", + " cat_pandas = fila['categoria']\n", + "\n", + " # Clasificación manual POO\n", + " if fila['mag'] < 6.0:\n", + " cat_poo = \"Moderado-Fuerte\"\n", + "\n", + " elif fila['mag'] < 7.0:\n", + " cat_poo = \"Fuerte\"\n", + "\n", + " elif fila['mag'] < 8.0:\n", + " cat_poo = \"Mayor\"\n", + "\n", + " else:\n", + " cat_poo = \"Gran terremoto\"\n", + "\n", + " # Imprime resultados\n", + " print(f\" {fila['mag']:>6.2f} {cat_pandas:>20} {cat_poo:>20}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "id": "f742163a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sismo más intenso del catálogo:\n", + " None\n", + " ¿Es peligroso? → None\n", + "\n", + "Sismos de categoría 'Mayor' en los primeros 50: 0\n", + "\n", + "Resumen del catálogo\n", + "----------------------------------------\n", + "Nombre: Sismos USGS — Semestre 1 de 2024\n", + "Cantidad de sismos: 50\n", + "Sismo más intenso: None\n", + "----------------------------------------\n" + ] + } + ], + "source": [ + "# Sismo más intenso del catálogo\n", + "\n", + "# Verifica si existen sismos en el catálogo\n", + "if len(catalogo._sismos) > 0:\n", + "\n", + " # Obtiene el sismo con mayor magnitud manualmente\n", + " mas_intenso = catalogo._sismos[0]\n", + "\n", + " # Recorre todos los sismos\n", + " for s in catalogo._sismos:\n", + "\n", + " # Compara magnitudes\n", + " if s.magnitud > mas_intenso.magnitud:\n", + "\n", + " # Actualiza el más intenso\n", + " mas_intenso = s\n", + "\n", + " # Imprime encabezado\n", + " print(\"Sismo más intenso del catálogo:\")\n", + "\n", + " # Imprime información del sismo\n", + " print(\" \", mas_intenso.descripcion())\n", + "\n", + " # Imprime si es peligroso\n", + " print(f\" ¿Es peligroso? → {mas_intenso.es_peligroso()}\\n\")\n", + "\n", + "else:\n", + "\n", + " # Mensaje si no hay datos\n", + " print(\"No hay sismos en el catálogo\")\n", + "\n", + "\n", + "# Filtrar por categoría\n", + "\n", + "# Lista para guardar resultados\n", + "mayores = []\n", + "\n", + "# Recorre todos los sismos\n", + "for s in catalogo._sismos:\n", + "\n", + " # Verifica categoría\n", + " if s.clasificar() == \"Mayor\":\n", + "\n", + " # Agrega coincidencia\n", + " mayores.append(s)\n", + "\n", + "# Imprime cantidad de sismos mayores\n", + "print(f\"Sismos de categoría 'Mayor' en los primeros 50: {len(mayores)}\\n\")\n", + "\n", + "\n", + "# Resumen completo\n", + "\n", + "# Encabezado\n", + "print(\"Resumen del catálogo\")\n", + "\n", + "# Línea decorativa\n", + "print(\"-\" * 40)\n", + "\n", + "# Nombre del catálogo\n", + "print(f\"Nombre: {catalogo.nombre}\")\n", + "\n", + "# Cantidad total\n", + "print(f\"Cantidad de sismos: {len(catalogo._sismos)}\")\n", + "\n", + "# Verifica existencia de sismos\n", + "if len(catalogo._sismos) > 0:\n", + "\n", + " # Imprime más intenso\n", + " print(f\"Sismo más intenso: {mas_intenso.descripcion()}\")\n", + "\n", + "# Línea decorativa\n", + "print(\"-\" * 40)" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "id": "2c65b37c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Verificación POO vs. pandas (primeros 10 sismos):\n", + " mag pandas Ej.3 POO clasificar() \n", + " ────────────────────────────────────────────────────\n", + " 5.60 Moderado Moderado-Fuerte ✗ REVISAR\n", + " 6.10 Fuerte Fuerte ✓\n", + " 5.70 Moderado Moderado-Fuerte ✗ REVISAR\n", + " 7.20 Mayor Mayor ✓\n", + " 5.90 Moderado Moderado-Fuerte ✗ REVISAR\n", + " 5.60 Moderado Moderado-Fuerte ✗ REVISAR\n", + " 6.30 Fuerte Fuerte ✓\n", + " 6.00 Fuerte Fuerte ✓\n", + " 5.50 Moderado Moderado-Fuerte ✗ REVISAR\n", + " 5.80 Moderado Moderado-Fuerte ✗ REVISAR\n" + ] + } + ], + "source": [ + "# Verificación: clasificar() debe coincidir con la columna 'categoria' del Ejercicio 3.\n", + "print(\"Verificación POO vs. pandas (primeros 10 sismos):\")\n", + "print(f\" {'mag':>6} {'pandas Ej.3':>15} {'POO clasificar()':>18} {'':>4}\")\n", + "print(\" \" + \"─\" * 52)\n", + "\n", + "for i, (indice, fila) in enumerate(sismos.head(10).iterrows()):\n", + " s = Sismo(\"\", \"\", fila['mag'], fila['depth'])\n", + " cat_poo = s.clasificar()\n", + " cat_pandas = fila['categoria']\n", + " marca = \"✓\" if cat_poo == cat_pandas else \"✗ REVISAR\"\n", + " print(f\" {fila['mag']:>6.2f} {cat_pandas:>15} {cat_poo:>18} {marca}\")" + ] + }, + { + "cell_type": "markdown", + "id": "e7131774", + "metadata": {}, + "source": [ + "#### Preguntas de interpretación — Ejercicio 5\n", + "\n", + "1. ¿Qué diferencia hay entre `EventoSismico` y `Sismo`?\n", + " ¿Por qué `Sismo.__init__` llama a `super().__init__(lugar, fecha)`?\n", + "\n", + " *Tu respuesta:* ___\n", + "\n", + "2. El método `clasificar()` de `Sismo` usa la misma lógica que la función\n", + " `clasificar_sismo()` del Ejercicio 3. ¿Qué ventaja tiene implementarlo\n", + " como método de una clase en lugar de como función suelta?\n", + "\n", + " *Tu respuesta:* ___\n", + "\n", + "3. Según `catalogo.resumen()`:\n", + " - ¿Cuántos sismos de categoría `'Mayor'` hay en los primeros 50? ___\n", + " - ¿El sismo más intenso resultó peligroso (`es_peligroso() == True`)? ___\n", + " - Justifica el resultado de `es_peligroso()` con los valores de magnitud y profundidad.\n", + "\n", + " *Tu respuesta:* ___\n", + "\n", + "4. ¿Todos los `✓` aparecen en la celda de verificación?\n", + " Si alguno muestra `✗`, ¿qué parte de tu método `clasificar()` necesita corrección?\n", + "\n", + " *Tu respuesta:* ___" + ] + }, + { + "cell_type": "markdown", + "id": "conclusion-md", + "metadata": {}, + "source": [ + "---\n", + "## Pregunta final — Conclusiones (incluida en el punteo del Ejercicio 4)\n", + "\n", + "Basándote en los datos analizados, escribe en la celda de abajo una conclusión\n", + "en tus propias palabras. Puedes guiarte con estas preguntas:\n", + "\n", + "- ¿Cuál fue el sismo más intenso del período y qué tan severo fue según la escala?\n", + "- ¿Qué tipo de escala de magnitud (`magType`) predomina y por qué crees que es así?\n", + "- ¿Qué relación observas entre la profundidad y la magnitud en el scatter plot?\n" + ] + }, + { + "cell_type": "markdown", + "id": "conclusion-answer", + "metadata": {}, + "source": [ + "---\n", + "## Conclusión final\n", + "\n", + "Basándote en **todos los valores que obtuviste** a lo largo del examen,\n", + "escribe un párrafo de al menos 5 oraciones que responda:\n", + "\n", + "- ¿Qué caracteriza la actividad sísmica global del primer semestre de 2024\n", + " según tu dataset personal?\n", + "- ¿Qué aprendiste sobre la distribución de magnitudes y profundidades?\n", + "- ¿Qué ventaja tiene usar pandas y NumPy sobre un ciclo `for` manual\n", + " para este tipo de análisis? Da un ejemplo concreto de tu examen.\n", + "\n", + "*(Escribe aquí tu respuesta — mínimo 5 oraciones)*\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "sello-md", + "metadata": {}, + "source": [ + "---\n", + "## Sello de entrega\n", + "\n", + "Ejecuta la siguiente celda **como último paso**, justo antes de guardar y subir el notebook.\n", + "\n", + "Registra la posición de la ISS en el momento exacto de tu entrega.\n", + "Dado que la ISS se desplaza ~7.7 km/s, dos estudiantes que entreguen\n", + "en momentos distintos obtendrán coordenadas completamente diferentes.\n", + "\n", + "> Este sello es **único e irrepetible**: queda vinculado a tu carnet\n", + "> y al instante exacto en que ejecutaste la celda.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "id": "sello-code", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consultando posicion de la ISS...\n", + "\n", + "=======================================================\n", + " SELLO DE ENTREGA -- EXAMEN FINAL A\n", + "=======================================================\n", + " Estudiante : Katy Ixchely Yaxón Saloj\n", + " Carnet : 201944830\n", + " Fecha/Hora : 2026-05-19 06:09:23 UTC\n", + " ISS Latitud : +22.2410 deg\n", + " ISS Longitud : -84.4946 deg\n", + " ISS Hora UTC : 2026-05-19 06:07:32 UTC\n", + "=======================================================\n" + ] + } + ], + "source": [ + "import requests as _req\n", + "from datetime import datetime, timezone\n", + "\n", + "print(\"Consultando posicion de la ISS...\")\n", + "try:\n", + " r_iss = _req.get(\"http://api.open-notify.org/iss-now.json\", timeout=8)\n", + " r_iss.raise_for_status()\n", + " iss = r_iss.json()\n", + " iss_lat = float(iss[\"iss_position\"][\"latitude\"])\n", + " iss_lon = float(iss[\"iss_position\"][\"longitude\"])\n", + " iss_hora = datetime.fromtimestamp(iss[\"timestamp\"], tz=timezone.utc).strftime(\"%Y-%m-%d %H:%M:%S UTC\")\n", + " iss_ok = True\n", + "except Exception as e:\n", + " iss_lat, iss_lon, iss_hora = 0.0, 0.0, \"no disponible\"\n", + " iss_ok = False\n", + " print(f\" Advertencia: sin datos ISS ({e})\")\n", + "\n", + "ts = datetime.now(tz=timezone.utc).strftime(\"%Y-%m-%d %H:%M:%S UTC\")\n", + "\n", + "print()\n", + "print(\"=\" * 55)\n", + "print(\" SELLO DE ENTREGA -- EXAMEN FINAL A\")\n", + "print(\"=\" * 55)\n", + "print(f\" Estudiante : {NOMBRE}\")\n", + "print(f\" Carnet : {CARNET}\")\n", + "print(f\" Fecha/Hora : {ts}\")\n", + "print(f\" ISS Latitud : {iss_lat:+.4f} deg\")\n", + "print(f\" ISS Longitud : {iss_lon:+.4f} deg\")\n", + "print(f\" ISS Hora UTC : {iss_hora}\")\n", + "print(\"=\" * 55)\n" + ] + }, + { + "cell_type": "markdown", + "id": "cierre", + "metadata": {}, + "source": [ + "---\n", + "## Entrega\n", + "\n", + "1. Ejecuta la celda **Sello de entrega** (arriba)\n", + "2. Guarda el notebook: **Archivo → Guardar** (o `Ctrl+S`)\n", + "3. Verifica que **todas las celdas tienen output** (ejecuta: **Kernel → Restart & Run All**)\n", + "4. Sube el archivo a tu repositorio en GitHub\n", + "5. Envía el enlace del notebook en el campo de entrega de **U Virtual**\n", + "\n", + "> **Ruta esperada en tu repositorio:** \n", + "> `examenes/python/examen_final/examen_final.ipynb`\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "39842093-24f5-4e9e-90be-dc5a3cc77a84", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examen_final_opcion_a/examen_final_poo_a.ipynb b/examen_final_opcion_a/examen_final_poo_a.ipynb new file mode 100644 index 0000000..9456c41 --- /dev/null +++ b/examen_final_opcion_a/examen_final_poo_a.ipynb @@ -0,0 +1,679 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "ed7bc3fe", + "metadata": {}, + "source": [ + "# Ejercicio 5 — Programación Orientada a Objetos\n", + "## Catálogo de Sismos USGS — Examen Final (Variante A)\n", + "\n", + "**Nombre:** Katy Ixchely Yaxón Saloj \n", + "**Carnet:** 201944830 \n", + "\n", + "---\n", + "\n", + "Este notebook usa las clases que implementaste en `poo_sismos.py`.\n", + "\n", + "**Requisito previo:** haber completado todos los métodos de `poo_sismos.py`.\n", + "\n", + "**Entrega:**\n", + "- `poo_sismos.py` con tu implementación\n", + "- Este notebook ejecutado con todos los outputs visibles\n", + "\n", + "> **Ruta esperada en tu repositorio:** \n", + "> `examenes/python/examen_final/poo_sismos.py` \n", + "> `examenes/python/examen_final/examen_final_poo_a.ipynb`" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "e0da0dd0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset cargado: 183 sismos\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
timelatitudelongitudedepthmagmagTypenstgapdminrms...updatedplacetypehorizontalErrordepthErrormagErrormagNststatuslocationSourcemagSource
02024-06-29T16:38:46.516Z-54.06337.230210.05.6mww209.016.018.2090.88...2024-09-04T21:57:44.040ZBouvet Island regionearthquake8.891.1930.08613.0reviewedusus
12024-06-29T07:05:32.855Z-16.0485-74.556018.06.1mww138.089.04.6060.71...2024-09-04T21:57:44.040Z34 km SW of Atiquipa, Peruearthquake7.961.8560.05928.0reviewedusus
22024-06-28T13:00:39.570Z-20.6490-175.631510.05.7mww75.038.00.6540.65...2024-10-09T03:15:27.209Z67 km NNW of Houma, Tongaearthquake6.561.7750.06920.0reviewedusus
\n", + "

3 rows × 22 columns

\n", + "
" + ], + "text/plain": [ + " time latitude longitude depth mag magType nst \\\n", + "0 2024-06-29T16:38:46.516Z -54.0633 7.2302 10.0 5.6 mww 209.0 \n", + "1 2024-06-29T07:05:32.855Z -16.0485 -74.5560 18.0 6.1 mww 138.0 \n", + "2 2024-06-28T13:00:39.570Z -20.6490 -175.6315 10.0 5.7 mww 75.0 \n", + "\n", + " gap dmin rms ... updated \\\n", + "0 16.0 18.209 0.88 ... 2024-09-04T21:57:44.040Z \n", + "1 89.0 4.606 0.71 ... 2024-09-04T21:57:44.040Z \n", + "2 38.0 0.654 0.65 ... 2024-10-09T03:15:27.209Z \n", + "\n", + " place type horizontalError depthError \\\n", + "0 Bouvet Island region earthquake 8.89 1.193 \n", + "1 34 km SW of Atiquipa, Peru earthquake 7.96 1.856 \n", + "2 67 km NNW of Houma, Tonga earthquake 6.56 1.775 \n", + "\n", + " magError magNst status locationSource magSource \n", + "0 0.086 13.0 reviewed us us \n", + "1 0.059 28.0 reviewed us us \n", + "2 0.069 20.0 reviewed us us \n", + "\n", + "[3 rows x 22 columns]" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "URL_SISMOS = (\n", + " \"https://earthquake.usgs.gov/fdsnws/event/1/query\"\n", + " \"?format=csv\"\n", + " \"&starttime=2024-01-01\"\n", + " \"&endtime=2024-06-30\"\n", + " \"&minmagnitude=5.5\"\n", + ")\n", + "\n", + "sismos = pd.read_csv(URL_SISMOS)\n", + "print(f\"Dataset cargado: {len(sismos)} sismos\")\n", + "sismos.head(3)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "58769d72", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Columna 'categoria' agregada.\n", + "categoria\n", + "Moderado-Fuerte 132\n", + "Fuerte 47\n", + "Mayor 4\n", + "Name: count, dtype: int64\n" + ] + } + ], + "source": [ + "# Reutiliza la función clasificar_sismo() del Ejercicio 3 para agregar la columna 'categoria'\n", + "def clasificar_sismo(mag):\n", + " if mag < 6.0:\n", + " return 'Moderado-Fuerte'\n", + " elif mag < 7.0:\n", + " return 'Fuerte'\n", + " elif mag < 8.0:\n", + " return 'Mayor'\n", + " else:\n", + " return 'Gran terremoto'\n", + "\n", + "sismos['categoria'] = sismos['mag'].apply(clasificar_sismo)\n", + "print(\"Columna 'categoria' agregada.\")\n", + "print(sismos['categoria'].value_counts())" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "cc728c91", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Clases importadas correctamente.\n" + ] + } + ], + "source": [ + "from poo_sismos import Sismo, CatalogoSismos\n", + "print(\"Clases importadas correctamente.\")" + ] + }, + { + "cell_type": "markdown", + "id": "04870eaa", + "metadata": {}, + "source": [ + "---\n", + "## Parte 1 — Probando la clase `Sismo` (objetos individuales)\n", + "\n", + "El siguiente bloque crea tres objetos `Sismo` representativos y llama a todos sus métodos. \n", + "Verifica que el output tiene sentido con los datos." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "00b92ed2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== Primero del dataset ===\n", + " Sismo mag=5.60 | Moderado-Fuerte | Superficial | Lugar: Bouvet Island region | Escala: mww\n", + " clasificar() → Moderado-Fuerte\n", + " clasificar_profundidad()→ Superficial\n", + " es_peligroso() → False\n", + "\n", + "=== Mayor magnitud ===\n", + " Sismo mag=7.50 | Mayor | Superficial | Lugar: 2024 Noto Peninsula, Japan Earthquake | Escala: mww\n", + " clasificar() → Mayor\n", + " clasificar_profundidad()→ Superficial\n", + " es_peligroso() → True\n", + "\n", + "=== Mayor profundidad ===\n", + " Sismo mag=6.50 | Fuerte | Profundo | Lugar: 70 km W of Tarauacá, Brazil | Escala: mww\n", + " clasificar() → Fuerte\n", + " clasificar_profundidad()→ Profundo\n", + " es_peligroso() → False\n", + "\n" + ] + } + ], + "source": [ + "import importlib\n", + "import poo_sismos\n", + "\n", + "# Recarga el archivo actualizado\n", + "importlib.reload(poo_sismos)\n", + "\n", + "# Importa clases nuevamente\n", + "from poo_sismos import EventoSismico, Sismo, CatalogoSismos\n", + "\n", + "# Tres sismos representativos del DataFrame\n", + "fila_primero = sismos.iloc[0]\n", + "fila_mayor = sismos.loc[sismos['mag'].idxmax()]\n", + "fila_profundo = sismos.loc[sismos['depth'].idxmax()]\n", + "\n", + "def crear_sismo(fila):\n", + " return Sismo(fila['place'], fila['time'], fila['mag'], fila['depth'], fila['magType'])\n", + "\n", + "s_primero = crear_sismo(fila_primero)\n", + "s_mayor = crear_sismo(fila_mayor)\n", + "s_profundo = crear_sismo(fila_profundo)\n", + "\n", + "for etiqueta, s in [(\"Primero del dataset\", s_primero),\n", + " (\"Mayor magnitud\", s_mayor),\n", + " (\"Mayor profundidad\", s_profundo)]:\n", + " print(f\"=== {etiqueta} ===\")\n", + " print(f\" {s}\")\n", + " print(f\" clasificar() → {s.clasificar()}\")\n", + " print(f\" clasificar_profundidad()→ {s.clasificar_profundidad()}\")\n", + " print(f\" es_peligroso() → {s.es_peligroso()}\")\n", + " print()" + ] + }, + { + "cell_type": "markdown", + "id": "8cd4a212", + "metadata": {}, + "source": [ + "### Tu turno — elige un sismo\n", + "\n", + "Crea un objeto `Sismo` usando **cualquier fila** del DataFrame que tú elijas \n", + "(puede ser el más reciente, uno de Guatemala, el más superficial, etc.). \n", + "Muestra su `descripcion()` y justifica tu elección en un comentario." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "ee39cc99", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sismo mag=7.50 | Mayor | Superficial | Lugar: 2024 Noto Peninsula, Japan Earthquake | Escala: mww\n", + "¿Es peligroso? True\n" + ] + } + ], + "source": [ + "# Elige una fila y crea tu propio objeto Sismo\n", + "# Elegí el sismo de mayor magnitud porque fue el evento más intenso del dataset\n", + "\n", + "# Obtiene fila del sismo más fuerte\n", + "mi_fila = sismos.loc[sismos['mag'].idxmax()]\n", + "\n", + "# Crea objeto Sismo\n", + "mi_sismo = Sismo(\n", + " mi_fila['place'],\n", + " mi_fila['time'],\n", + " mi_fila['mag'],\n", + " mi_fila['depth'],\n", + " mi_fila['magType']\n", + ")\n", + "\n", + "# Imprime descripción\n", + "print(mi_sismo)\n", + "\n", + "# Imprime si es peligroso\n", + "print(f\"¿Es peligroso? {mi_sismo.es_peligroso()}\")" + ] + }, + { + "cell_type": "markdown", + "id": "3d053eca", + "metadata": {}, + "source": [ + "---\n", + "## Parte 2 — Construyendo el `CatalogoSismos` con todos los datos\n", + "\n", + "Ahora crea el catálogo con **todos** los sismos del DataFrame (no solo 50) y ejerce los métodos de consulta." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "095f2d14", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Catálogo construido: 183 sismos\n" + ] + } + ], + "source": [ + "catalogo = CatalogoSismos(\"Sismos Globales — Semestre 1 de 2024\")\n", + "\n", + "for indice, fila in sismos.iterrows():\n", + " catalogo.agregar(Sismo(\n", + " lugar = fila['place'],\n", + " fecha = fila['time'],\n", + " magnitud = fila['mag'],\n", + " profundidad = fila['depth'],\n", + " tipo_escala = fila['magType'],\n", + " ))\n", + "\n", + "print(f\"Catálogo construido: {len(catalogo._sismos)} sismos\")" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "8d5bf23f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sismo más intenso del catálogo completo:\n", + " Sismo mag=7.50 | Mayor | Superficial | Lugar: 2024 Noto Peninsula, Japan Earthquake | Escala: mww\n", + " ¿Es peligroso? → True\n" + ] + } + ], + "source": [ + "# ── el_mas_intenso() ────────────────────────────────────────────────────────\n", + "mas_intenso = catalogo.el_mas_intenso()\n", + "print(\"Sismo más intenso del catálogo completo:\")\n", + "print(\" \", mas_intenso)\n", + "print(f\" ¿Es peligroso? → {mas_intenso.es_peligroso()}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "0eb3406c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sismos por categoría (catálogo completo):\n", + " Moderado-Fuerte : 132 sismos\n", + " Sismo mag=5.60 | Moderado-Fuerte | Superficial | Lugar: Bouvet Island region | Escala: mww\n", + " Sismo mag=5.70 | Moderado-Fuerte | Superficial | Lugar: 67 km NNW of Houma, Tonga | Escala: mww\n", + " Fuerte : 47 sismos\n", + " Sismo mag=6.10 | Fuerte | Superficial | Lugar: 34 km SW of Atiquipa, Peru | Escala: mww\n", + " Sismo mag=6.30 | Fuerte | Intermedio | Lugar: 49 km NNE of Port-Olry, Vanuatu | Escala: mww\n", + " Mayor : 4 sismos\n", + " Sismo mag=7.20 | Mayor | Superficial | Lugar: 10 km WSW of Atiquipa, Peru | Escala: mww\n", + " Sismo mag=7.40 | Mayor | Superficial | Lugar: 15 km S of Hualien City, Taiwan | Escala: mww\n", + " Gran terremoto : 0 sismos\n" + ] + } + ], + "source": [ + "# ── filtrar_por_categoria() ──────────────────────────────────────────────────\n", + "print(\"Sismos por categoría (catálogo completo):\")\n", + "for cat in ['Moderado-Fuerte', 'Fuerte', 'Mayor', 'Gran terremoto']:\n", + " grupo = catalogo.filtrar_por_categoria(cat)\n", + " print(f\" {cat:<18}: {len(grupo)} sismos\")\n", + " # Muestra los primeros 2 de cada categoría\n", + " for s in grupo[:2]:\n", + " print(f\" {s}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "07e31032", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Catálogo: Sismos Globales — Semestre 1 de 2024\n", + "Total de sismos: 183\n", + "Sismo más intenso: Sismo mag=7.50 | Mayor | Superficial | Lugar: 2024 Noto Peninsula, Japan Earthquake | Escala: mww\n", + "Moderado-Fuerte: 132\n", + "Fuerte: 47\n", + "Mayor: 4\n", + "Gran terremoto: 0\n" + ] + } + ], + "source": [ + "# ── resumen() ────────────────────────────────────────────────────────────────\n", + "catalogo.resumen()" + ] + }, + { + "cell_type": "markdown", + "id": "c9dea605", + "metadata": {}, + "source": [ + "### Tu turno — sismos peligrosos\n", + "\n", + "Usa `filtrar_por_categoria()` y el método `es_peligroso()` para \n", + "**listar todos los sismos que son peligrosos** (Mayor o Gran terremoto, superficiales). \n", + "Muestra cuántos hay y su `descripcion()`." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "8d70308f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sismos peligrosos encontrados:\n", + "\n", + "Sismo mag=7.20 | Mayor | Superficial | Lugar: 10 km WSW of Atiquipa, Peru | Escala: mww\n", + "Sismo mag=7.40 | Mayor | Superficial | Lugar: 15 km S of Hualien City, Taiwan | Escala: mww\n", + "Sismo mag=7.00 | Mayor | Superficial | Lugar: 128 km WNW of Aykol, China | Escala: mww\n", + "Sismo mag=7.50 | Mayor | Superficial | Lugar: 2024 Noto Peninsula, Japan Earthquake | Escala: mww\n", + "\n", + "Total de sismos peligrosos: 4\n" + ] + } + ], + "source": [ + "# Hint: usa filtrar_por_categoria() para obtener 'Mayor' y 'Gran terremoto'\n", + "# luego filtra los que es_peligroso() == True con un for\n", + "\n", + "# Obtiene sismos categoría Mayor\n", + "mayores = catalogo.filtrar_por_categoria(\"Mayor\")\n", + "\n", + "# Obtiene sismos categoría Gran terremoto\n", + "grandes = catalogo.filtrar_por_categoria(\"Gran terremoto\")\n", + "\n", + "# Une ambas listas\n", + "todos = mayores + grandes\n", + "\n", + "# Lista de sismos peligrosos\n", + "peligrosos = []\n", + "\n", + "# Recorre todos los candidatos\n", + "for s in todos:\n", + "\n", + " # Verifica si es peligroso\n", + " if s.es_peligroso():\n", + "\n", + " # Agrega a la lista\n", + " peligrosos.append(s)\n", + "\n", + "# Encabezado\n", + "print(\"Sismos peligrosos encontrados:\\n\")\n", + "\n", + "# Muestra resultados\n", + "for s in peligrosos:\n", + "\n", + " # Imprime descripción\n", + " print(s)\n", + "\n", + "# Cantidad total\n", + "print(f\"\\nTotal de sismos peligrosos: {len(peligrosos)}\")" + ] + }, + { + "cell_type": "markdown", + "id": "e1d2d63c", + "metadata": {}, + "source": [ + "---\n", + "## Parte 3 — Verificación automática\n", + "\n", + "Esta celda confirma que tu `clasificar()` produce los mismos resultados \n", + "que la función `clasificar_sismo()` del Ejercicio 3 para **todos** los sismos." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "e0e7a410", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✓ Todos los 183 sismos clasifican correctamente.\n" + ] + } + ], + "source": [ + "errores = 0\n", + "for _, fila in sismos.iterrows():\n", + " s = Sismo(\"\", \"\", fila['mag'], fila['depth'])\n", + " if s.clasificar() != fila['categoria']:\n", + " errores += 1\n", + " print(f\" ✗ mag={fila['mag']:.2f} pandas={fila['categoria']} poo={s.clasificar()}\")\n", + "\n", + "if errores == 0:\n", + " print(f\"✓ Todos los {len(sismos)} sismos clasifican correctamente.\")\n", + "else:\n", + " print(f\"✗ {errores} sismos con clasificación incorrecta. Revisa tu método clasificar().\")" + ] + }, + { + "cell_type": "markdown", + "id": "d832189f", + "metadata": {}, + "source": [ + "---\n", + "## Preguntas de interpretación\n", + "\n", + "1. ¿Cuántos sismos peligrosos (`es_peligroso() == True`) encontraste en el catálogo completo? \n", + " ¿En qué regiones del mundo ocurrieron?\n", + "\n", + " *Tu respuesta:* Se encontraron 4 sismos peligrosos en el catálogo completo. La mayoría ocurrieron en regiones cercanas al cinturón de fuego del Pacífico, especialmente en Japón y otras zonas con alta actividad sísmica.\n", + "\n", + "2. ¿Cuántos sismos de categoría `'Gran terremoto'` (mag ≥ 8.0) hay en el semestre? \n", + " Si no hay ninguno, ¿por qué tiene sentido dada la frecuencia global de ese tipo de evento?\n", + "\n", + " *Tu respuesta:* Hubo 0 sismos clasificados como “Gran terremoto” en el catálogo completo. Esto tiene sentido porque los terremotos de magnitud extremadamente alta son eventos poco frecuentes a nivel mundial.\n", + "\n", + "3. ¿Qué ventaja tiene usar la clase `CatalogoSismos` frente a trabajar directamente \n", + " con el DataFrame de pandas para este tipo de consultas?\n", + "\n", + " *Tu respuesta:* La clase `CatalogoSismos` permite organizar mejor los datos y trabajar con métodos específicos como `el_mas_intenso()` o `filtrar_por_categoria()`. Además, hace que el código sea más reutilizable, más ordenado y más fácil de mantener que usar consultas manuales directamente sobre el DataFrame." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a75fce8c-e4fd-4495-b341-c6820d7f810e", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examen_final_opcion_a/poo_sismos.py b/examen_final_opcion_a/poo_sismos.py new file mode 100644 index 0000000..88341e2 --- /dev/null +++ b/examen_final_opcion_a/poo_sismos.py @@ -0,0 +1,330 @@ +""" +Ejercicio 5 — Programación Orientada a Objetos +Examen Final — Programación 1 (F12) — Variante A: Sismos USGS + +Instrucciones: + Implementa todos los métodos marcados con # TU CÓDIGO AQUÍ + No modifiques los métodos ya implementados ni los __init__. + Cuando termines, regresa al notebook y ejecuta el Ejercicio 5. +""" + + +class EventoSismico: + """Representa un evento sísmico genérico registrado en algún lugar del mundo.""" + + def __init__(self, lugar, fecha): + # Guarda el lugar del evento sísmico + self.lugar = lugar + + # Guarda la fecha del evento sísmico + self.fecha = fecha + + def clasificar(self): + """ + Clasifica el evento según su intensidad. + Este método debe ser sobreescrito en la clase hija. + + Retorna: + str: categoría del evento + """ + + # Método vacío porque será implementado en la clase hija + pass + + def descripcion(self): + """ + Retorna una descripción legible del evento. + Este método debe ser sobreescrito en la clase hija. + + Retorna: + str: descripción del evento + """ + + # Método vacío porque será implementado en la clase hija + pass + + def __str__(self): + # Retorna la descripción del evento o una descripción genérica + return self.descripcion() or f"EventoSismico en {self.lugar}" + + def __repr__(self): + # Retorna una representación técnica del objeto + return f"{self.__class__.__name__}(lugar={self.lugar!r}, fecha={self.fecha!r})" + + +class Sismo(EventoSismico): + """ + Representa un sismo con sus atributos medidos. + + Atributos: + lugar (str) : descripción del lugar (columna 'place' del DataFrame) + fecha (str) : fecha y hora UTC del evento (columna 'time') + magnitud (float) : magnitud del sismo (columna 'mag') + profundidad (float) : profundidad del foco en km (columna 'depth') + tipo_escala (str) : escala de magnitud usada (columna 'magType') + """ + + def __init__(self, lugar, fecha, magnitud, profundidad, tipo_escala="mww"): + # Llama al constructor de la clase padre + super().__init__(lugar, fecha) + + # Guarda la magnitud del sismo + self.magnitud = magnitud + + # Guarda la profundidad del sismo + self.profundidad = profundidad + + # Guarda el tipo de escala usada + self.tipo_escala = tipo_escala + + def clasificar(self): + """ + Clasifica el sismo según su magnitud. + + Usa la misma escala que aplicaste en el Ejercicio 3: + 5.5 ≤ magnitud < 6.0 → 'Moderado-Fuerte' + 6.0 ≤ magnitud < 7.0 → 'Fuerte' + 7.0 ≤ magnitud < 8.0 → 'Mayor' + magnitud ≥ 8.0 → 'Gran terremoto' + + Hint: usa if / elif / elif / else sobre self.magnitud + + Retorna: + str: categoría del sismo + """ + + # Verifica si la magnitud es menor a 6.0 + if self.magnitud < 6.0: + + # Retorna categoría Moderado-Fuerte + return "Moderado-Fuerte" + + # Verifica si la magnitud es menor a 7.0 + elif self.magnitud < 7.0: + + # Retorna categoría Fuerte + return "Fuerte" + + # Verifica si la magnitud es menor a 8.0 + elif self.magnitud < 8.0: + + # Retorna categoría Mayor + return "Mayor" + + # Para magnitudes de 8.0 o superiores + else: + + # Retorna categoría Gran terremoto + return "Gran terremoto" + + def clasificar_profundidad(self): + """ + Clasifica el sismo según la profundidad del foco. + + Escala vista en el enunciado del examen: + profundidad < 70 km → 'Superficial' + 70 ≤ profundidad < 300 km → 'Intermedio' + profundidad ≥ 300 km → 'Profundo' + + Hint: usa if / elif / else sobre self.profundidad + + Retorna: + str: tipo de sismo por profundidad + """ + + # Verifica si la profundidad es menor a 70 km + if self.profundidad < 70: + + # Retorna clasificación superficial + return "Superficial" + + # Verifica si la profundidad es menor a 300 km + elif self.profundidad < 300: + + # Retorna clasificación intermedia + return "Intermedio" + + # Para profundidades iguales o mayores a 300 km + else: + + # Retorna clasificación profunda + return "Profundo" + + def es_peligroso(self): + """ + Determina si el sismo es potencialmente peligroso en superficie. + + Criterio: magnitud >= 7.0 Y profundidad < 70 km + (un sismo Mayor o Gran terremoto que además es superficial) + + Hint: combina dos condiciones con 'and' + + Retorna: + bool: True si cumple ambos criterios, False en caso contrario + """ + + # Evalúa si cumple ambas condiciones + return self.magnitud >= 7.0 and self.profundidad < 70 + + def descripcion(self): + """ + Retorna una cadena con el resumen del sismo. + + Formato esperado (usa los métodos clasificar y clasificar_profundidad): + "Sismo mag=7.10 | Mayor | Superficial | Lugar: Tonga Region | Escala: mww" + + Hint: llama a self.clasificar() y self.clasificar_profundidad() dentro del f-string + + Retorna: + str: descripción formateada del sismo + """ + + # Construye y retorna la descripción completa + return ( + f"Sismo mag={self.magnitud:.2f} | " + f"{self.clasificar()} | " + f"{self.clasificar_profundidad()} | " + f"Lugar: {self.lugar} | " + f"Escala: {self.tipo_escala}" + ) + + def __str__(self): + # Retorna la descripción del objeto + return self.descripcion() + + def __repr__(self): + # Retorna representación técnica del objeto + return ( + f"Sismo(lugar={self.lugar!r}, magnitud={self.magnitud}, " + f"profundidad={self.profundidad}, tipo_escala={self.tipo_escala!r})" + ) + + +class CatalogoSismos: + """ + Colección de objetos Sismo con métodos de consulta y resumen. + + Atributos: + nombre (str) : nombre descriptivo del catálogo + _sismos (list) : lista interna de objetos Sismo + """ + + def __init__(self, nombre="Catálogo de Sismos"): + + # Guarda el nombre del catálogo + self.nombre = nombre + + # Inicializa lista vacía de sismos + self._sismos = [] + + def agregar(self, sismo): + """Agrega un objeto Sismo al catálogo.""" + + # Agrega el objeto sismo a la lista + self._sismos.append(sismo) + + def __len__(self): + """Retorna el total de sismos en el catálogo.""" + + # Retorna la cantidad total de sismos + return len(self._sismos) + + def el_mas_intenso(self): + """ + Encuentra el sismo con la mayor magnitud. + + Usa un ciclo for para iterar sobre self._sismos. + Guarda el mayor encontrado en una variable auxiliar. + Compara con sismo.magnitud en cada iteración. + + Retorna: + Sismo : el objeto con la magnitud más alta + None : si el catálogo está vacío + """ + + # Verifica si la lista está vacía + if not self._sismos: + + # Retorna None si no hay sismos + return None + + # Guarda inicialmente el primer sismo como el más intenso + mayor = self._sismos[0] + + # Recorre todos los sismos del catálogo + for sismo in self._sismos: + + # Verifica si el sismo actual tiene mayor magnitud + if sismo.magnitud > mayor.magnitud: + + # Actualiza el sismo más intenso + mayor = sismo + + # Retorna el sismo más intenso encontrado + return mayor + + def filtrar_por_categoria(self, categoria): + """ + Retorna una lista con todos los sismos de la categoría dada. + + Parámetro: + categoria (str): 'Moderado-Fuerte', 'Fuerte', 'Mayor' o 'Gran terremoto' + + Hint: usa un ciclo for y llama a sismo.clasificar() en cada iteración. + Agrega a una lista auxiliar los que coincidan. + + Retorna: + list: lista de objetos Sismo filtrada (puede estar vacía) + """ + + # Lista auxiliar para almacenar coincidencias + filtrados = [] + + # Recorre todos los sismos + for sismo in self._sismos: + + # Verifica si la categoría coincide + if sismo.clasificar() == categoria: + + # Agrega el sismo a la lista filtrada + filtrados.append(sismo) + + # Retorna la lista filtrada + return filtrados + + def resumen(self): + """ + Imprime un resumen del catálogo. + + Debe mostrar: + 1. Nombre del catálogo y total de sismos (usa len(self)) + 2. El sismo más intenso (usa el_mas_intenso()) + 3. Cantidad de sismos en cada categoría (usa filtrar_por_categoria()) + + Hint: itera sobre las categorías con un for: + categorias = ['Moderado-Fuerte', 'Fuerte', 'Mayor', 'Gran terremoto'] + """ + + # Imprime el nombre del catálogo + print(f"Catálogo: {self.nombre}") + + # Imprime la cantidad total de sismos + print(f"Total de sismos: {len(self)}") + + # Obtiene el sismo más intenso + mas_intenso = self.el_mas_intenso() + + # Imprime el sismo más intenso + print(f"Sismo más intenso: {mas_intenso}") + + # Lista de categorías + categorias = ['Moderado-Fuerte', 'Fuerte', 'Mayor', 'Gran terremoto'] + + # Recorre cada categoría + for categoria in categorias: + + # Obtiene lista filtrada de la categoría actual + cantidad = len(self.filtrar_por_categoria(categoria)) + + # Imprime la cantidad encontrada + print(f"{categoria}: {cantidad}") diff --git a/examen_parcial2/examen_parcial2_estudiante.html b/examen_parcial2/examen_parcial2_estudiante.html new file mode 100644 index 0000000..4be0800 --- /dev/null +++ b/examen_parcial2/examen_parcial2_estudiante.html @@ -0,0 +1,9124 @@ + + + + + +examen_parcial2_estudiante + + + + + + + + + + + + +
+ + + + + + + + + + + + + + + +
+ + diff --git a/examen_parcial2/examen_parcial2_estudiante.ipynb b/examen_parcial2/examen_parcial2_estudiante.ipynb new file mode 100644 index 0000000..f4b86a0 --- /dev/null +++ b/examen_parcial2/examen_parcial2_estudiante.ipynb @@ -0,0 +1,1102 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "title", + "metadata": {}, + "source": [ + "# Examen Parcial 2 — Programación 1 (F12)\n", + "## Tormentas Geomagnéticas con la API de NASA / DONKI\n", + "\n", + "**Nombre:** Katy Ixchely Yaxón Saloj \n", + "**Carnet:** 201944830 \n", + "**Fecha:** 22-4-26 \n", + "**Punteo total:** 100 puntos\n", + "\n", + "---\n", + "\n", + "| Ejercicio | Tema | Puntos |\n", + "|---|---|:---:|\n", + "| 1a | Construir la URL y realizar la solicitud HTTP | 10 |\n", + "| 1b | Explorar la lista de tormentas con un ciclo `for` | 10 |\n", + "| 2 | Calcular el Kp máximo e identificar la tormenta más intensa | 20 |\n", + "| 3 | Función `clasificar_kp()` con condicionales | 25 |\n", + "| 4 | Función `analizar_tormenta()` que retorna un diccionario | 35 |\n", + "| | **Total** | **100** |\n", + "\n", + "---\n", + "\n", + "> **Instrucciones generales**\n", + "> - Completa cada ejercicio en la celda indicada.\n", + "> - Ejecuta las celdas **en orden** de arriba hacia abajo.\n", + "> - Puedes consultar tus apuntes y el notebook de clase `XML_JSON_APIs.ipynb`.\n", + "> - Entrega el notebook con **todas las celdas ejecutadas** (con output visible)." + ] + }, + { + "cell_type": "markdown", + "id": "background", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "---\n", + "## Contexto: ¿Qué es una tormenta geomagnética?\n", + "\n", + "El Sol emite constantemente partículas cargadas (viento solar). Cuando ocurre una erupción solar intensa, una ola de partículas choca con el campo magnético de la Tierra y provoca una **tormenta geomagnética**.\n", + "\n", + "Estos eventos pueden:\n", + "- Generar auroras boreales visibles en latitudes bajas\n", + "- Interferir con satélites GPS y comunicaciones de radio\n", + "- En casos extremos, dañar redes eléctricas (como el apagón de Quebec en 1989)\n", + "\n", + "### Índice Kp — escala de intensidad\n", + "\n", + "El **índice Kp** (0–9) mide la perturbación del campo magnético terrestre:\n", + "\n", + "| Kp | Categoría | Descripción |\n", + "|---|---|---|\n", + "| 0 – 3 | Quieto | Sin tormenta |\n", + "| 4 | Activo | Perturbación menor |\n", + "| 5 | **G1** — Menor | Auroras en latitudes altas |\n", + "| 6 | **G2** — Moderada | Auroras hasta latitud 55° |\n", + "| 7 | **G3** — Fuerte | Auroras hasta latitud 50° |\n", + "| 8 | **G4** — Severa | Problemas en redes eléctricas |\n", + "| 9 | **G5** — Extrema | Apagones posibles, auroras tropicales |\n", + "\n", + "La tormenta de mayo 2024 alcanzó **G5** — la más intensa en 20 años." + ] + }, + { + "cell_type": "markdown", + "id": "api-docs", + "metadata": {}, + "source": [ + "---\n", + "## El endpoint: DONKI / GST\n", + "\n", + "**DONKI** = Space Weather Database Of Notifications, Knowledge, Information \n", + "**GST** = Geomagnetic Storm\n", + "\n", + "```\n", + "GET https://api.nasa.gov/DONKI/GST\n", + "```\n", + "\n", + "| Parámetro | Tipo | Default | Descripción |\n", + "|---|---|---|---|\n", + "| `startDate` | YYYY-MM-DD | 30 días atrás | Inicio del rango de fechas |\n", + "| `endDate` | YYYY-MM-DD | hoy | Fin del rango de fechas |\n", + "| `api_key` | string | DEMO_KEY | Tu API key de api.nasa.gov |\n", + "\n", + "**Ejemplo de URL:**\n", + "```\n", + "https://api.nasa.gov/DONKI/GST?startDate=2024-05-01&endDate=2024-05-31&api_key=DEMO_KEY\n", + "```\n", + "\n", + "### Estructura de la respuesta\n", + "\n", + "La API devuelve una **lista** de eventos. Cada evento es un diccionario con esta estructura:\n", + "\n", + "```json\n", + "{\n", + " \"gstID\": \"2024-05-10T17:00:00-GST-001\",\n", + " \"startTime\": \"2024-05-10T17:00Z\",\n", + " \"allKpIndex\": [\n", + " { \"observedTime\": \"2024-05-10T21:00Z\", \"kpIndex\": 8.67, \"source\": \"NOAA\" },\n", + " { \"observedTime\": \"2024-05-11T00:00Z\", \"kpIndex\": 9.0, \"source\": \"NOAA\" }\n", + " ],\n", + " \"linkedEvents\": [\n", + " { \"activityID\": \"2024-05-08T21:08:00-CME-001\" }\n", + " ],\n", + " \"link\": \"https://webtools.ccmc.gsfc.nasa.gov/DONKI/view/GST/...\"\n", + "}\n", + "```\n", + "\n", + "**Campos importantes:**\n", + "- `gstID` — identificador único del evento\n", + "- `startTime` — cuándo comenzó la tormenta (formato ISO 8601 UTC)\n", + "- `allKpIndex` — lista de mediciones Kp durante la tormenta\n", + "- `linkedEvents` — eventos espaciales relacionados (erupciones, CME) — puede ser `None`" + ] + }, + { + "cell_type": "markdown", + "id": "setup-title", + "metadata": {}, + "source": [ + "---\n", + "## Paso 1 — Configuración de la API Key\n", + "\n", + "### Obtener tu API key (gratis)\n", + "\n", + "1. Ve a **https://api.nasa.gov**\n", + "2. Completa el formulario con tu nombre y correo electrónico\n", + "3. Haz clic en **\"Signup\"**\n", + "4. Revisa tu correo — recibirás la key en minutos\n", + "5. La key tiene este formato: `TU_API_KEY_AQUI_XXXXXXXXXXXXXXXXXXXXXXXX`\n", + "\n", + "Con tu propia key puedes hacer **1,000 solicitudes por hora** (vs 30 con DEMO_KEY).\n", + "\n", + "---\n", + "\n", + "### Configurar la variable de entorno `NASA_API_KEY`\n", + "\n", + "Una variable de entorno guarda tu key **fuera del código**, para que no quede expuesta \n", + "en el archivo del notebook ni en el historial de git.\n", + "\n", + "#### Linux / macOS — temporal (solo la sesión actual)\n", + "```bash\n", + "export NASA_API_KEY=\"tu_key_aqui\"\n", + "jupyter notebook\n", + "```\n", + "\n", + "#### Linux / macOS — permanente\n", + "Agrega esta línea al final de `~/.bashrc` (bash) o `~/.zshrc` (zsh):\n", + "```bash\n", + "echo 'export NASA_API_KEY=\"tu_key_aqui\"' >> ~/.bashrc\n", + "source ~/.bashrc # aplicar sin reiniciar\n", + "```\n", + "\n", + "#### Windows — PowerShell (temporal)\n", + "```powershell\n", + "$env:NASA_API_KEY = \"tu_key_aqui\"\n", + "jupyter notebook\n", + "```\n", + "\n", + "#### Windows — permanente (Panel de control)\n", + "1. Busca **\"Variables de entorno\"** en el menú Inicio\n", + "2. Clic en **\"Editar las variables de entorno del sistema\"**\n", + "3. Botón **\"Variables de entorno...\"**\n", + "4. En \"Variables de usuario\" → **Nueva**\n", + "5. Nombre: `NASA_API_KEY` | Valor: tu key\n", + "6. Aceptar y **reiniciar** Jupyter\n", + "\n", + "#### Verificar que está configurada\n", + "```bash\n", + "# Linux/macOS\n", + "echo $NASA_API_KEY\n", + "\n", + "# Windows PowerShell\n", + "echo $env:NASA_API_KEY\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "setup-code", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "API key cargada: 8Iqa************************************\n", + "\n", + "Librerías importadas correctamente\n" + ] + } + ], + "source": [ + "import os\n", + "import requests\n", + "import json\n", + "import time\n", + "\n", + "# Cargar la API key desde la variable de entorno.\n", + "# Si no está configurada, usa DEMO_KEY como respaldo (30 req/hora).\n", + "API_KEY = os.getenv(\"NASA_API_KEY\", \"\").strip() or \"DEMO_KEY\"\n", + "\n", + "if API_KEY == \"DEMO_KEY\":\n", + " print(\"Usando DEMO_KEY — límite: 30 solicitudes/hora\")\n", + " print(\" Configura NASA_API_KEY para mayor límite (ver instrucciones arriba).\")\n", + "else:\n", + " print(f\"API key cargada: {API_KEY[:4]}{'*' * (len(API_KEY) - 4)}\")\n", + "\n", + "print(\"\\nLibrerías importadas correctamente\")" + ] + }, + { + "cell_type": "markdown", + "id": "ident-md", + "metadata": {}, + "source": [ + "---\n", + "## Identificacion del estudiante\n", + "\n", + "Completa tu nombre y carnet en la siguiente celda y **ejecutala antes de comenzar**. \n", + "Estos datos quedan registrados en el output del notebook junto con la posicion de la ISS \n", + "en el momento exacto en que realizas el examen." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ident-code", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Estudiante : Katy Ixchely Yaxón Saloj\n", + "Carnet : 201944830\n" + ] + } + ], + "source": [ + "# Completa tus datos\n", + "NOMBRE = \"Katy Ixchely Yaxón Saloj\" # TU NOMBRE AQUI\n", + "CARNET = \"201944830\" # TU CARNET AQUI\n", + "\n", + "if NOMBRE == \"Nombre Apellido\" or CARNET == \"202300000\":\n", + " raise ValueError(\"Completa tu nombre y carnet antes de continuar.\")\n", + "\n", + "print(f\"Estudiante : {NOMBRE}\")\n", + "print(f\"Carnet : {CARNET}\")" + ] + }, + { + "cell_type": "markdown", + "id": "ej1-md", + "metadata": {}, + "source": [ + "---\n", + "## Ejercicio 1 — Obtener y explorar los datos (20 pts)\n", + "\n", + "### Parte a) — Solicitud al endpoint (10 pts)\n", + "\n", + "Se te da la URL base del endpoint. Construye la URL completa usando un f-string e incluye los parámetros `startDate`, `endDate` y `api_key`. Luego realiza la solicitud y verifica que fue exitosa.\n", + "\n", + "---\n", + "\n", + "### ¿Por qué verificar el código de estado antes de leer el JSON?\n", + "\n", + "Cuando hacemos una solicitud HTTP el servidor siempre responde con un **código de estado numérico** que indica si todo salió bien o hubo un problema.\n", + "\n", + "El código **200** significa *\"OK — la solicitud fue exitosa y el cuerpo de la respuesta contiene los datos pedidos\"*.\n", + "\n", + "Si el servidor devuelve un código diferente (por ejemplo **503 - Service Unavailable** o **429 - Too Many Requests**), el cuerpo de la respuesta **no contiene JSON válido** — puede estar vacío o contener un mensaje de error en texto plano. Si intentamos llamar `.json()` directamente sin verificar, el programa lanzará un `JSONDecodeError`.\n", + "\n", + "Por eso siempre debemos verificar que `respuesta.status_code == 200` (o equivalentemente `respuesta.ok`) **antes** de intentar parsear la respuesta.\n", + "\n", + "> **Escribe en la celda de código siguiente: ¿qué imprimirías tú para que el usuario sepa qué salió mal cuando el código no es 200?**" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ej1-code", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ellipsis\n" + ] + }, + { + "ename": "SystemExit", + "evalue": "No se pudo obtener la respuesta. Intenta de nuevo.", + "output_type": "error", + "traceback": [ + "An exception has occurred, use %tb to see the full traceback.\n", + "\u001b[31mSystemExit\u001b[39m\u001b[31m:\u001b[39m No se pudo obtener la respuesta. Intenta de nuevo.\n" + ] + } + ], + "source": [ + "URL_BASE = \"https://api.nasa.gov/DONKI/GST\"\n", + "\n", + "# Agrega también los parámetros startDate y endDate:\n", + "# startDate = \"2024-05-01\"\n", + "# endDate = \"2024-05-31\"\n", + "# Hint: los parámetros van separados por \"&\" → ?param1=val1¶m2=val2\n", + "\n", + "url = f\"\" # TU CÓDIGO AQUÍ\n", + "\n", + "# Completa la llamada — usa timeout=15\n", + "respuesta = ... # TU CÓDIGO AQUÍ\n", + "\n", + "# Verifica que la respuesta fue exitosa antes de parsear el JSON\n", + "# Hint: usa respuesta.ok o compara respuesta.status_code con 200\n", + "# Hint: si hay error, imprime el código y el cuerpo — respuesta.text tiene el mensaje\n", + "if ...: # TU CÓDIGO AQUÍ — condición de error\n", + " print(...) # TU CÓDIGO AQUÍ — mensaje informativo\n", + " raise SystemExit(\"No se pudo obtener la respuesta. Intenta de nuevo.\")\n", + "\n", + "tormentas = respuesta.json()\n", + "print(f\"Solicitud exitosa — {len(tormentas)} tormentas recibidas\")" + ] + }, + { + "cell_type": "markdown", + "id": "ej1-url-warning", + "metadata": {}, + "source": [ + "> ⚠️ **Cuidado con exponer tu API key** \n", + "> Puedes descomentar el `print` de la celda siguiente para verificar que la URL se formó correctamente, pero **vuelve a comentarlo antes de guardar y entregar el notebook**. Si lo dejas activo, tu API key quedará visible en el output del archivo." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "ej1-url-check", + "metadata": {}, + "outputs": [], + "source": [ + "# Descomenta la siguiente línea para verificar que la URL se formó correctamente.\n", + "# ⚠ Vuelve a comentarla antes de entregar — el output guarda tu API key en el archivo.\n", + "\n", + "# print(\"URL:\", url)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "15a022de-6d7b-484b-9c47-810984f71d9f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "API key cargada correctamente\n" + ] + } + ], + "source": [ + "# Importamos librerías necesarias\n", + "import os\n", + "import requests\n", + "\n", + "# Obtenemos la API key desde la variable de entorno\n", + "API_KEY = os.getenv(\"NASA_API_KEY\", \"\").strip() or \"DEMO_KEY\"\n", + "\n", + "# Mensaje informativo (opcional, pero útil)\n", + "if API_KEY == \"DEMO_KEY\":\n", + " print(\"Usando DEMO_KEY (límite bajo)\")\n", + "else:\n", + " print(\"API key cargada correctamente\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "77d10917-be5b-421b-a311-ec9406185b44", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solicitud exitosa — 5 tormentas recibidas\n" + ] + } + ], + "source": [ + "# Definimos la URL base del endpoint de NASA\n", + "URL_BASE = \"https://api.nasa.gov/DONKI/GST\"\n", + "\n", + "# Definimos la fecha de inicio del rango solicitado\n", + "startDate = \"2024-05-01\"\n", + "\n", + "# Definimos la fecha final del rango solicitado\n", + "endDate = \"2024-05-31\"\n", + "\n", + "# Construimos la URL completa usando f-string e incluyendo los parámetros requeridos\n", + "url = f\"{URL_BASE}?startDate={startDate}&endDate={endDate}&api_key={API_KEY}\"\n", + "\n", + "# Realizamos la solicitud HTTP GET al endpoint con un timeout de 15 segundos\n", + "respuesta = requests.get(url, timeout=15)\n", + "\n", + "# Verificamos si la respuesta NO fue exitosa\n", + "if not respuesta.ok:\n", + " # Imprimimos el código de error HTTP para informar al usuario\n", + " print(f\"Error HTTP: {respuesta.status_code}\")\n", + " \n", + " # Imprimimos el mensaje del servidor para más detalles del error\n", + " print(f\"Mensaje del servidor: {respuesta.text}\")\n", + " \n", + " # Terminamos el programa si ocurre un error\n", + " raise SystemExit(\"No se pudo obtener la respuesta. Intenta de nuevo.\")\n", + "\n", + "# Convertimos la respuesta JSON en una estructura de Python (lista de diccionarios)\n", + "tormentas = respuesta.json()\n", + "\n", + "# Mostramos cuántas tormentas se recibieron\n", + "print(f\"Solicitud exitosa — {len(tormentas)} tormentas recibidas\")" + ] + }, + { + "cell_type": "markdown", + "id": "ej1b-md", + "metadata": {}, + "source": [ + "### Parte b) — Explorar la lista de tormentas (10 pts)\n", + "\n", + "Usando un ciclo `for`, imprime cuántas tormentas hubo en el período y el `gstID` y `startTime` de cada una." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "ej1b-code", + "metadata": {}, + "outputs": [], + "source": [ + "# Hint: len(tormentas) da el total de eventos\n", + "# Hint: cada elemento de tormentas es un dict — accede con tormenta[\"gstID\"], etc.\n", + "\n", + "# TU CÓDIGO AQUÍ\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "c81f0459-c6dd-4afb-a096-be3e065023ea", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total de tormentas: 5\n", + "\n", + "ID: 2024-05-02T15:00:00-GST-001 | Inicio: 2024-05-02T15:00Z\n", + "ID: 2024-05-10T15:00:00-GST-001 | Inicio: 2024-05-10T15:00Z\n", + "ID: 2024-05-12T21:00:00-GST-001 | Inicio: 2024-05-12T21:00Z\n", + "ID: 2024-05-16T06:00:00-GST-001 | Inicio: 2024-05-16T06:00Z\n", + "ID: 2024-05-17T18:00:00-GST-001 | Inicio: 2024-05-17T18:00Z\n" + ] + } + ], + "source": [ + "# Imprimimos el total de tormentas usando len()\n", + "print(f\"Total de tormentas: {len(tormentas)}\\n\")\n", + "\n", + "# Recorremos cada tormenta dentro de la lista\n", + "for tormenta in tormentas:\n", + " \n", + " # Imprimimos el ID y el tiempo de inicio de cada tormenta\n", + " print(f\"ID: {tormenta['gstID']} | Inicio: {tormenta['startTime']}\")" + ] + }, + { + "cell_type": "markdown", + "id": "ej2-md", + "metadata": {}, + "source": [ + "---\n", + "## Ejercicio 2 — Kp máximo por tormenta (20 pts)\n", + "\n", + "Cada tormenta contiene una lista `allKpIndex` con múltiples mediciones a lo largo del tiempo.\n", + "\n", + "**a) (10 pts)** Para cada tormenta, encuentra el **valor máximo de Kp** usando un ciclo `for` sobre `allKpIndex`. Imprime el `startTime` y el Kp máximo de cada tormenta.\n", + "\n", + "**b) (10 pts)** Encuentra e imprime la tormenta **más intensa** del período (la que tuvo el mayor Kp máximo entre todas las tormentas)." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "ej2-code", + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "unsupported format string passed to ellipsis.__format__", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mTypeError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[12]\u001b[39m\u001b[32m, line 10\u001b[39m\n\u001b[32m 6\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m tormenta \u001b[38;5;28;01min\u001b[39;00m tormentas:\n\u001b[32m 7\u001b[39m \u001b[38;5;66;03m# TU CÓDIGO AQUÍ — obtener el kp máximo de esta tormenta\u001b[39;00m\n\u001b[32m 8\u001b[39m kp_max = ...\n\u001b[32m 9\u001b[39m \n\u001b[32m---> \u001b[39m\u001b[32m10\u001b[39m print(f\" {tormenta[\u001b[33m'startTime'\u001b[39m]} Kp máx = {kp_max:.2f}\")\n\u001b[32m 11\u001b[39m \n\u001b[32m 12\u001b[39m \u001b[38;5;66;03m# ── Parte b) ──────────────────────────────────────────────────────────────────\u001b[39;00m\n\u001b[32m 13\u001b[39m \u001b[38;5;66;03m# Hint: necesitas dos variables auxiliares:\u001b[39;00m\n", + "\u001b[31mTypeError\u001b[39m: unsupported format string passed to ellipsis.__format__" + ] + } + ], + "source": [ + "# ── Parte a) ──────────────────────────────────────────────────────────────────\n", + "# Hint: allKpIndex es una lista de dicts, cada uno con la clave \"kpIndex\"\n", + "# Hint: para encontrar el máximo de una lista puedes usar la función max()\n", + "# o un ciclo que compare con una variable auxiliar (kp_max = 0)\n", + "\n", + "for tormenta in tormentas:\n", + " # TU CÓDIGO AQUÍ — obtener el kp máximo de esta tormenta\n", + " kp_max = ...\n", + "\n", + " print(f\" {tormenta['startTime']} Kp máx = {kp_max:.2f}\")\n", + "\n", + "# ── Parte b) ──────────────────────────────────────────────────────────────────\n", + "# Hint: necesitas dos variables auxiliares:\n", + "# tormenta_mas_intensa = None\n", + "# kp_global_max = 0\n", + "# Recorre todas las tormentas y actualiza estas variables cuando encuentres un Kp mayor\n", + "\n", + "# TU CÓDIGO AQUÍ\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6c851de9-8fcf-4edd-87b9-e59803950222", + "metadata": {}, + "outputs": [], + "source": [ + "# Recorremos cada tormenta en la lista\n", + "for tormenta in tormentas:\n", + " \n", + " # Extraemos la lista de mediciones de Kp\n", + " mediciones = tormenta[\"allKpIndex\"]\n", + " \n", + " # Creamos una lista con los valores de kpIndex de cada medición\n", + " valores_kp = [m[\"kpIndex\"] for m in mediciones]\n", + " \n", + " # Calculamos el valor máximo de Kp\n", + " kp_max = max(valores_kp)\n", + " \n", + " # Imprimimos el tiempo de inicio y el Kp máximo\n", + " print(f\" {tormenta['startTime']} Kp máx = {kp_max:.2f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "39f686eb-5750-4ec5-843c-39066b215a40", + "metadata": {}, + "outputs": [], + "source": [ + "# Inicializamos variable para guardar la tormenta más intensa\n", + "tormenta_mas_intensa = None\n", + "\n", + "# Inicializamos el valor máximo global de Kp\n", + "kp_global_max = 0\n", + "\n", + "# Recorremos todas las tormentas\n", + "for tormenta in tormentas:\n", + " \n", + " # Extraemos los valores de Kp\n", + " valores_kp = [m[\"kpIndex\"] for m in tormenta[\"allKpIndex\"]]\n", + " \n", + " # Calculamos el máximo de esta tormenta\n", + " kp_max = max(valores_kp)\n", + " \n", + " # Si encontramos un valor mayor al actual, actualizamos\n", + " if kp_max > kp_global_max:\n", + " kp_global_max = kp_max\n", + " tormenta_mas_intensa = tormenta\n", + "\n", + "# Imprimimos la tormenta más intensa encontrada\n", + "print(\"\\nTormenta más intensa:\")\n", + "print(f\"Inicio: {tormenta_mas_intensa['startTime']}\")\n", + "print(f\"Kp máximo global: {kp_global_max:.2f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "ej3-md", + "metadata": {}, + "source": [ + "---\n", + "## Ejercicio 3 — Clasificar la severidad con condicionales (25 pts)\n", + "\n", + "**a) (15 pts)** Escribe una función `clasificar_kp(kp)` que reciba un valor de Kp (float) y retorne una cadena con la categoría según la tabla del contexto:\n", + "- Kp < 4 → `\"Quieto\"`\n", + "- Kp == 4 → `\"Activo\"`\n", + "- Kp == 5 → `\"G1 - Menor\"`\n", + "- Kp == 6 → `\"G2 - Moderada\"`\n", + "- Kp == 7 → `\"G3 - Fuerte\"`\n", + "- Kp == 8 → `\"G4 - Severa\"`\n", + "- Kp >= 9 → `\"G5 - Extrema\"`\n", + "\n", + "> **Nota:** el índice Kp puede ser decimal (ej. 8.67). Usa `int(kp)` para redondear hacia abajo y comparar.\n", + "\n", + "**b) (10 pts)** Usa tu función para imprimir una tabla con cada tormenta, su Kp máximo y su categoría." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "d04da2f2-6f6d-4413-b6b6-244caea361c9", + "metadata": {}, + "outputs": [], + "source": [ + "def clasificar_kp(kp):\n", + " \"\"\"Clasifica la intensidad de una tormenta según el índice Kp.\"\"\"\n", + " \n", + " # Convertimos el valor a entero para clasificar correctamente\n", + " kp_entero = int(kp)\n", + " \n", + " # Evaluamos cada rango de la escala\n", + " if kp_entero < 4:\n", + " return \"Quieto\"\n", + " elif kp_entero == 4:\n", + " return \"Activo\"\n", + " elif kp_entero == 5:\n", + " return \"G1 - Menor\"\n", + " elif kp_entero == 6:\n", + " return \"G2 - Moderada\"\n", + " elif kp_entero == 7:\n", + " return \"G3 - Fuerte\"\n", + " elif kp_entero == 8:\n", + " return \"G4 - Severa\"\n", + " else:\n", + " return \"G5 - Extrema\"" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "ej3-code", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " kp=2.00 → None\n", + " kp=4.00 → None\n", + " kp=5.33 → None\n", + " kp=6.67 → None\n", + " kp=7.00 → None\n", + " kp=8.67 → None\n", + " kp=9.00 → None\n", + "\n", + "Fecha inicio Kp máx Categoría\n", + "--------------------------------------------------\n" + ] + } + ], + "source": [ + "# ── Parte a) ──────────────────────────────────────────────────────────────────\n", + "# Hint: usa if / elif / else\n", + "# Hint: int(8.67) == 8 — esto te permite usar comparaciones exactas con enteros\n", + "\n", + "def clasificar_kp(kp):\n", + " \"\"\"Clasifica la intensidad de una tormenta según el índice Kp.\"\"\"\n", + " # TU CÓDIGO AQUÍ\n", + " pass\n", + "\n", + "\n", + "# Prueba tu función con estos valores — verifica que los resultados son correctos:\n", + "for kp_prueba in [2.0, 4.0, 5.33, 6.67, 7.0, 8.67, 9.0]:\n", + " print(f\" kp={kp_prueba:.2f} → {clasificar_kp(kp_prueba)}\")\n", + "\n", + "# ── Parte b) ──────────────────────────────────────────────────────────────────\n", + "print(f\"\\n{'Fecha inicio':<22} {'Kp máx':>7} {'Categoría'}\")\n", + "print(\"-\" * 50)\n", + "\n", + "# TU CÓDIGO AQUÍ — recorre tormentas, calcula kp_max, llama clasificar_kp()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "c332e0d4-97a1-4f9e-9ae9-c5aa04e09fd7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Fecha inicio Kp máx Categoría\n", + "--------------------------------------------------\n", + "2024-05-02T15:00Z 6.67 None\n", + "2024-05-10T15:00Z 9.00 None\n", + "2024-05-12T21:00Z 6.33 None\n", + "2024-05-16T06:00Z 6.00 None\n", + "2024-05-17T18:00Z 6.00 None\n" + ] + } + ], + "source": [ + "# Imprimimos encabezado de la tabla\n", + "print(f\"\\n{'Fecha inicio':<22} {'Kp máx':>7} {'Categoría'}\")\n", + "\n", + "# Línea separadora\n", + "print(\"-\" * 50)\n", + "\n", + "# Recorremos cada tormenta\n", + "for tormenta in tormentas:\n", + " \n", + " # Extraemos valores de Kp\n", + " valores_kp = [m[\"kpIndex\"] for m in tormenta[\"allKpIndex\"]]\n", + " \n", + " # Calculamos el máximo\n", + " kp_max = max(valores_kp)\n", + " \n", + " # Clasificamos la tormenta\n", + " categoria = clasificar_kp(kp_max)\n", + " \n", + " # Imprimimos en formato de tabla\n", + " print(f\"{tormenta['startTime']:<22} {kp_max:>7.2f} {categoria}\")" + ] + }, + { + "cell_type": "markdown", + "id": "ej4-md", + "metadata": {}, + "source": [ + "---\n", + "## Ejercicio 4 — Función de análisis completa (35 pts)\n", + "\n", + "Escribe una función `analizar_tormenta(tormenta)` que reciba **un evento** de la lista `tormentas` y retorne un **diccionario** con las siguientes claves:\n", + "\n", + "| Clave | Valor esperado |\n", + "|---|---|\n", + "| `\"id\"` | el `gstID` del evento |\n", + "| `\"inicio\"` | el `startTime` |\n", + "| `\"kp_max\"` | el valor Kp más alto entre todas las mediciones |\n", + "| `\"kp_min\"` | el valor Kp más bajo entre todas las mediciones |\n", + "| `\"kp_promedio\"` | promedio de todos los valores Kp (redondeado a 2 decimales) |\n", + "| `\"num_mediciones\"` | cuántas mediciones hay en `allKpIndex` |\n", + "| `\"categoria\"` | resultado de llamar `clasificar_kp(kp_max)` |\n", + "| `\"eventos_vinculados\"` | número de eventos en `linkedEvents` (0 si es `None`) |\n", + "\n", + "Luego aplícala a **todas las tormentas** con un ciclo `for` e imprime un resumen de cada una." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "ej4-code", + "metadata": {}, + "outputs": [], + "source": [ + "def analizar_tormenta(tormenta):\n", + " \"\"\"\n", + " Analiza un evento de tormenta geomagnética.\n", + " \n", + " Parámetro:\n", + " tormenta (dict): un elemento de la lista retornada por el endpoint GST.\n", + " \n", + " Retorna:\n", + " dict con las claves: id, inicio, kp_max, kp_min, kp_promedio,\n", + " num_mediciones, categoria, eventos_vinculados.\n", + " \"\"\"\n", + " # Hint: extrae la lista de mediciones primero\n", + " mediciones = tormenta[\"allKpIndex\"]\n", + " \n", + " # Hint: para kp_promedio, suma todos los kpIndex y divide entre len(mediciones)\n", + " # usa round(..., 2) para redondear a 2 decimales\n", + " \n", + " # Hint: linkedEvents puede ser None — usa (tormenta[\"linkedEvents\"] or [])\n", + " # para tratar None como lista vacía y poder llamar len() sin error\n", + " \n", + " # TU CÓDIGO AQUÍ\n", + " resultado = {\n", + " \"id\": ...,\n", + " \"inicio\": ...,\n", + " \"kp_max\": ...,\n", + " \"kp_min\": ...,\n", + " \"kp_promedio\": ...,\n", + " \"num_mediciones\": ...,\n", + " \"categoria\": ...,\n", + " \"eventos_vinculados\": ...,\n", + " }\n", + " return resultado\n", + "\n", + "\n", + "# Aplicar a todas las tormentas e imprimir resumen\n", + "for tormenta in tormentas:\n", + " r = analizar_tormenta(tormenta)\n", + " # Hint: accede a cada clave del dict retornado con r[\"clave\"]\n", + " # TU CÓDIGO AQUÍ — imprime los campos de r de forma legible\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "3946b7a5-46a6-465f-aa4d-c74b8477be21", + "metadata": {}, + "outputs": [], + "source": [ + "def analizar_tormenta(tormenta):\n", + " \"\"\"\n", + " Analiza un evento de tormenta geomagnética.\n", + " \"\"\"\n", + " \n", + " # Extraemos la lista de mediciones\n", + " mediciones = tormenta[\"allKpIndex\"]\n", + " \n", + " # Obtenemos los valores de Kp\n", + " valores_kp = [m[\"kpIndex\"] for m in mediciones]\n", + " \n", + " # Calculamos el valor máximo\n", + " kp_max = max(valores_kp)\n", + " \n", + " # Calculamos el valor mínimo\n", + " kp_min = min(valores_kp)\n", + " \n", + " # Calculamos el promedio redondeado a 2 decimales\n", + " kp_promedio = round(sum(valores_kp) / len(valores_kp), 2)\n", + " \n", + " # Contamos el número de mediciones\n", + " num_mediciones = len(mediciones)\n", + " \n", + " # Clasificamos la tormenta según su intensidad\n", + " categoria = clasificar_kp(kp_max)\n", + " \n", + " # Contamos los eventos vinculados (manejo de None)\n", + " eventos_vinculados = len(tormenta[\"linkedEvents\"] or [])\n", + " \n", + " # Creamos el diccionario resultado\n", + " resultado = {\n", + " \"id\": tormenta[\"gstID\"],\n", + " \"inicio\": tormenta[\"startTime\"],\n", + " \"kp_max\": kp_max,\n", + " \"kp_min\": kp_min,\n", + " \"kp_promedio\": kp_promedio,\n", + " \"num_mediciones\": num_mediciones,\n", + " \"categoria\": categoria,\n", + " \"eventos_vinculados\": eventos_vinculados\n", + " }\n", + " \n", + " # Retornamos el diccionario\n", + " return resultado" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "55fff22b-470a-4dba-8bc7-ef79e304e45d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--- Tormenta ---\n", + "ID: 2024-05-02T15:00:00-GST-001\n", + "Inicio: 2024-05-02T15:00Z\n", + "Kp máx: 6.67\n", + "Kp mín: 6.67\n", + "Kp promedio: 6.67\n", + "Mediciones: 2\n", + "Categoría: None\n", + "Eventos vinculados: 2\n", + "\n", + "--- Tormenta ---\n", + "ID: 2024-05-10T15:00:00-GST-001\n", + "Inicio: 2024-05-10T15:00Z\n", + "Kp máx: 9.0\n", + "Kp mín: 6.67\n", + "Kp promedio: 8.13\n", + "Mediciones: 13\n", + "Categoría: None\n", + "Eventos vinculados: 6\n", + "\n", + "--- Tormenta ---\n", + "ID: 2024-05-12T21:00:00-GST-001\n", + "Inicio: 2024-05-12T21:00Z\n", + "Kp máx: 6.33\n", + "Kp mín: 5.67\n", + "Kp promedio: 6.0\n", + "Mediciones: 3\n", + "Categoría: None\n", + "Eventos vinculados: 2\n", + "\n", + "--- Tormenta ---\n", + "ID: 2024-05-16T06:00:00-GST-001\n", + "Inicio: 2024-05-16T06:00Z\n", + "Kp máx: 6.0\n", + "Kp mín: 6.0\n", + "Kp promedio: 6.0\n", + "Mediciones: 1\n", + "Categoría: None\n", + "Eventos vinculados: 1\n", + "\n", + "--- Tormenta ---\n", + "ID: 2024-05-17T18:00:00-GST-001\n", + "Inicio: 2024-05-17T18:00Z\n", + "Kp máx: 6.0\n", + "Kp mín: 6.0\n", + "Kp promedio: 6.0\n", + "Mediciones: 1\n", + "Categoría: None\n", + "Eventos vinculados: 2\n" + ] + } + ], + "source": [ + "# Recorremos cada tormenta\n", + "for tormenta in tormentas:\n", + " \n", + " # Analizamos la tormenta\n", + " r = analizar_tormenta(tormenta)\n", + " \n", + " # Imprimimos resultados de forma legible\n", + " print(\"\\n--- Tormenta ---\")\n", + " print(f\"ID: {r['id']}\")\n", + " print(f\"Inicio: {r['inicio']}\")\n", + " print(f\"Kp máx: {r['kp_max']}\")\n", + " print(f\"Kp mín: {r['kp_min']}\")\n", + " print(f\"Kp promedio: {r['kp_promedio']}\")\n", + " print(f\"Mediciones: {r['num_mediciones']}\")\n", + " print(f\"Categoría: {r['categoria']}\")\n", + " print(f\"Eventos vinculados: {r['eventos_vinculados']}\")" + ] + }, + { + "cell_type": "markdown", + "id": "conclusion-md", + "metadata": {}, + "source": [ + "---\n", + "## Pregunta final — Conclusiones (incluida en el punteo del Ejercicio 4)\n", + "\n", + "Basandote en los datos que obtuviste a lo largo del examen, escribe en la celda de abajo \n", + "una conclusion en tus propias palabras. Puedes responder estas preguntas como guia:\n", + "\n", + "- ¿Cual fue la tormenta mas intensa del periodo analizado y que tan severa fue segun la escala Kp?\n", + "- ¿Que patrones observas en los datos? (frecuencia, intensidad, eventos vinculados)\n", + "- ¿Que impacto podria haber tenido una tormenta de esa magnitud en la vida cotidiana?" + ] + }, + { + "cell_type": "markdown", + "id": "conclusion-answer", + "metadata": {}, + "source": [ + "**Conclusiones:**\n", + "\n", + "Durante el análisis de las tormentas geomagnéticas de mayo de 2024 se identificaron un total de 5 eventos. La tormenta más intensa ocurrió el 2024-05-10, alcanzando un valor máximo de Kp = 9.00, lo cual corresponde a una categoría G5 - Extrema.\n", + "\n", + "Se observó que la mayoría de las tormentas presentaron intensidades moderadas (G2), con valores cercanos a Kp 6, lo que indica que los eventos de intensidad media fueron los más frecuentes durante el período analizado. Por otro lado, la tormenta más intensa también fue la que tuvo mayor número de mediciones y eventos vinculados, evidenciando una actividad solar más compleja.\n", + "\n", + "En cuanto a patrones, se puede concluir que a mayor intensidad de la tormenta, mayor es la cantidad de mediciones y eventos relacionados, lo que refleja una evolución más prolongada y significativa del fenómeno.\n", + "\n", + "Una tormenta de magnitud G5 puede tener impactos importantes en la vida cotidiana, como fallas en sistemas GPS, interrupciones en comunicaciones, afectaciones en satélites y posibles problemas en redes eléctricas. Esto resalta la importancia del monitoreo del clima espacial mediante herramientas como la API de NASA." + ] + }, + { + "cell_type": "markdown", + "id": "sello-md", + "metadata": {}, + "source": [ + "---\n", + "## Sello de entrega\n", + "\n", + "Ejecuta la siguiente celda **como ultimo paso**, justo antes de guardar y subir el notebook.\n", + "\n", + "Realiza una consulta a la API de la ISS para registrar tu posicion geografica aproximada \n", + "al momento de entregar. Dado que la ISS se desplaza ~30 km cada 4 segundos, dos estudiantes \n", + "que entreguen en momentos distintos obtendran coordenadas completamente diferentes.\n", + "\n", + "> Este sello es **unico e irrepetible**: queda vinculado a tu carnet y al instante \n", + "> exacto en que ejecutaste la celda." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "sello-code", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consultando posicion de la ISS...\n", + "\n", + "=======================================================\n", + " SELLO DE ENTREGA -- PARCIAL 2\n", + "=======================================================\n", + " Estudiante : Katy Ixchely Yaxón Saloj\n", + " Carnet : 201944830\n", + " Fecha/Hora : 2026-04-22 05:05:23 UTC\n", + " ISS Latitud : +45.5170 deg\n", + " ISS Longitud : -15.3553 deg\n", + " ISS Hora UTC : 2026-04-22 05:03:53 UTC\n", + "=======================================================\n" + ] + } + ], + "source": [ + "from datetime import datetime, timezone\n", + "\n", + "# Obtener la posicion actual de la ISS\n", + "print(\"Consultando posicion de la ISS...\")\n", + "try:\n", + " r_iss = requests.get(\"http://api.open-notify.org/iss-now.json\", timeout=8)\n", + " r_iss.raise_for_status()\n", + " iss_data = r_iss.json()\n", + " iss_lat = float(iss_data[\"iss_position\"][\"latitude\"])\n", + " iss_lon = float(iss_data[\"iss_position\"][\"longitude\"])\n", + " iss_ts = iss_data[\"timestamp\"]\n", + " iss_hora = datetime.fromtimestamp(iss_ts, tz=timezone.utc).strftime(\"%Y-%m-%d %H:%M:%S UTC\")\n", + " iss_ok = True\n", + "except Exception as e:\n", + " iss_lat, iss_lon, iss_hora = 0.0, 0.0, \"no disponible\"\n", + " iss_ok = False\n", + " print(f\" Advertencia: no se pudo obtener la posicion ISS ({e})\")\n", + "\n", + "# Timestamp local del momento de entrega\n", + "ts_entrega = datetime.now(tz=timezone.utc).strftime(\"%Y-%m-%d %H:%M:%S UTC\")\n", + "\n", + "# Imprimir el sello\n", + "print()\n", + "print(\"=\" * 55)\n", + "print(\" SELLO DE ENTREGA -- PARCIAL 2\")\n", + "print(\"=\" * 55)\n", + "print(f\" Estudiante : {NOMBRE}\")\n", + "print(f\" Carnet : {CARNET}\")\n", + "print(f\" Fecha/Hora : {ts_entrega}\")\n", + "print(f\" ISS Latitud : {iss_lat:+.4f} deg\")\n", + "print(f\" ISS Longitud : {iss_lon:+.4f} deg\")\n", + "print(f\" ISS Hora UTC : {iss_hora}\")\n", + "print(\"=\" * 55)\n", + "\n", + "if not iss_ok:\n", + " print(\" Advertencia: sello generado sin datos de ISS (sin conexion).\")\n", + " print(\" Guarda el notebook de todas formas.\")" + ] + }, + { + "cell_type": "markdown", + "id": "cierre", + "metadata": {}, + "source": [ + "---\n", + "## Entrega\n", + "\n", + "1. Ejecuta la celda **Sello de entrega** (arriba)\n", + "2. Guarda el notebook: **Archivo → Guardar** (o `Ctrl+S`)\n", + "3. Verifica que **todas las celdas tienen output** (ejecuta: **Kernel → Restart & Run All**)\n", + "4. Sube el archivo a Github y copia el link en el campo de entrega en la U Virtual" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6e9a231d-3229-4072-92d4-bac281a69979", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examen_parcial2/examen_parcial2_estudiante.pdf b/examen_parcial2/examen_parcial2_estudiante.pdf new file mode 100644 index 0000000..a50a78e Binary files /dev/null and b/examen_parcial2/examen_parcial2_estudiante.pdf differ diff --git a/practicas/python/analisis_datos/notebooks/Sol_analisis_estrellas.pdf b/practicas/python/analisis_datos/notebooks/Sol_analisis_estrellas.pdf new file mode 100644 index 0000000..592be5a Binary files /dev/null and b/practicas/python/analisis_datos/notebooks/Sol_analisis_estrellas.pdf differ diff --git a/practicas/python/analisis_datos/notebooks/analisis_estrellas.ipynb b/practicas/python/analisis_datos/notebooks/analisis_estrellas.ipynb new file mode 100644 index 0000000..9aa68cb --- /dev/null +++ b/practicas/python/analisis_datos/notebooks/analisis_estrellas.ipynb @@ -0,0 +1,1057 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "72be6588", + "metadata": {}, + "source": [ + "# Práctica 2 — Análisis Exploratorio de Datos con Python" + ] + }, + { + "cell_type": "markdown", + "id": "f1d78564", + "metadata": {}, + "source": [ + "# Importación de librerías" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "93e2b98f", + "metadata": {}, + "outputs": [], + "source": [ + "# =========================================================\n", + "# IMPORTACIÓN DE LIBRERÍAS\n", + "# =========================================================\n", + "\n", + "# NumPy se usa para operaciones matemáticas y arreglos\n", + "import numpy as np\n", + "\n", + "# Pandas se usa para manejo y análisis de datos\n", + "import pandas as pd\n", + "\n", + "# Matplotlib se usa para crear gráficas\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Seaborn se usa para gráficas estadísticas más avanzadas\n", + "import seaborn as sns" + ] + }, + { + "cell_type": "markdown", + "id": "a8ec8b2b", + "metadata": {}, + "source": [ + "# Carga del dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "e7f57aae", + "metadata": {}, + "outputs": [], + "source": [ + "# =========================================================\n", + "# CARGA DEL DATASET\n", + "# =========================================================\n", + "\n", + "# Cargamos el archivo CSV dentro de un DataFrame\n", + "stars = pd.read_csv(\"star_dataset.csv\")" + ] + }, + { + "cell_type": "markdown", + "id": "e87c1a22", + "metadata": {}, + "source": [ + "# Mostrar primeras filas" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "9adbefdf", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
NameDistance (ly)Luminosity (L/Lo)Radius (R/Ro)Temperature (K)Spectral Class
0Altair16.5941719.9791921.6326507509.294247A7V
1Deneb2600.490723196002.627856202.9705268503.284796A2Ia
2Barnard's Star6.0526164.8937160.2227113165.959639M4Ve
3Polaris322.6010022196.24193437.5468136048.326915F7Ib
4Barnard's Star5.902392-1.4964860.1923593130.602069M4Ve
\n", + "
" + ], + "text/plain": [ + " Name Distance (ly) Luminosity (L/Lo) Radius (R/Ro) \\\n", + "0 Altair 16.594171 9.979192 1.632650 \n", + "1 Deneb 2600.490723 196002.627856 202.970526 \n", + "2 Barnard's Star 6.052616 4.893716 0.222711 \n", + "3 Polaris 322.601002 2196.241934 37.546813 \n", + "4 Barnard's Star 5.902392 -1.496486 0.192359 \n", + "\n", + " Temperature (K) Spectral Class \n", + "0 7509.294247 A7V \n", + "1 8503.284796 A2Ia \n", + "2 3165.959639 M4Ve \n", + "3 6048.326915 F7Ib \n", + "4 3130.602069 M4Ve " + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# =========================================================\n", + "# MOSTRAR LAS PRIMERAS FILAS\n", + "# =========================================================\n", + "\n", + "# Mostramos las primeras 5 filas del dataset\n", + "stars.head()" + ] + }, + { + "cell_type": "markdown", + "id": "252e63d5", + "metadata": {}, + "source": [ + "# Dimensiones del dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "03bcbbfd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dimensiones del dataset:\n", + "(1000, 6)\n" + ] + } + ], + "source": [ + "# =========================================================\n", + "# DIMENSIONES DEL DATASET\n", + "# =========================================================\n", + "\n", + "print(\"Dimensiones del dataset:\")\n", + "print(stars.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "ab59228c", + "metadata": {}, + "source": [ + "# Tipos de datos" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "84cac23d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tipos de datos del dataset:\n", + "Name object\n", + "Distance (ly) float64\n", + "Luminosity (L/Lo) float64\n", + "Radius (R/Ro) float64\n", + "Temperature (K) float64\n", + "Spectral Class object\n", + "dtype: object\n" + ] + } + ], + "source": [ + "# =========================================================\n", + "# TIPOS DE DATOS\n", + "# =========================================================\n", + "\n", + "print(\"Tipos de datos del dataset:\")\n", + "print(stars.dtypes)" + ] + }, + { + "cell_type": "markdown", + "id": "3f542fa1", + "metadata": {}, + "source": [ + "# Estadísticas descriptivas" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "9828922d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Estadísticas descriptivas:\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Distance (ly)Luminosity (L/Lo)Radius (R/Ro)Temperature (K)
count1000.0000001000.0000001000.0000001000.000000
mean295.50532719644.90944286.9606969983.486779
std541.47840342223.595017213.8500057906.973529
min3.877798-4.9931410.0680872750.183163
25%11.71685310.4410391.6644793940.020856
50%52.031435171.0978095.8454447379.007975
75%322.86587410500.57711733.71977812055.975095
max2600.490723196004.854081887.09793628044.279272
\n", + "
" + ], + "text/plain": [ + " Distance (ly) Luminosity (L/Lo) Radius (R/Ro) Temperature (K)\n", + "count 1000.000000 1000.000000 1000.000000 1000.000000\n", + "mean 295.505327 19644.909442 86.960696 9983.486779\n", + "std 541.478403 42223.595017 213.850005 7906.973529\n", + "min 3.877798 -4.993141 0.068087 2750.183163\n", + "25% 11.716853 10.441039 1.664479 3940.020856\n", + "50% 52.031435 171.097809 5.845444 7379.007975\n", + "75% 322.865874 10500.577117 33.719778 12055.975095\n", + "max 2600.490723 196004.854081 887.097936 28044.279272" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# =========================================================\n", + "# ESTADÍSTICAS DESCRIPTIVAS\n", + "# =========================================================\n", + "\n", + "print(\"Estadísticas descriptivas:\")\n", + "stars.describe()" + ] + }, + { + "cell_type": "markdown", + "id": "d2982a2d", + "metadata": {}, + "source": [ + "# Valores nulos" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "e9fbc2a7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Valores nulos por columna:\n", + "Name 0\n", + "Distance (ly) 0\n", + "Luminosity (L/Lo) 0\n", + "Radius (R/Ro) 0\n", + "Temperature (K) 0\n", + "Spectral Class 0\n", + "dtype: int64\n" + ] + } + ], + "source": [ + "# =========================================================\n", + "# VERIFICAR VALORES NULOS\n", + "# =========================================================\n", + "\n", + "print(\"Valores nulos por columna:\")\n", + "print(stars.isnull().sum())" + ] + }, + { + "cell_type": "markdown", + "id": "aa718945", + "metadata": {}, + "source": [ + "# Conteo por clase espectral" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "5b046562", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cantidad de estrellas por clase espectral:\n", + "Spectral Class\n", + "A7V 74\n", + "A1V 73\n", + "A9II 48\n", + "B1III 45\n", + "M3.5V 45\n", + "M2Iab 44\n", + "G8III 39\n", + "M4Ve 38\n", + "K1.5III 38\n", + "A0V 38\n", + "M7IIIe 37\n", + "B2III 37\n", + "B0Ia 36\n", + "G2V 36\n", + "F7Ib 35\n", + "B1III-IV 32\n", + "A3V 31\n", + "F5IV-V 30\n", + "B0.5IV 30\n", + "B6Vep 29\n", + "M2.1V 27\n", + "B7V 26\n", + "M1.5Iab 26\n", + "A2Ia 25\n", + "K1V 24\n", + "M6V 22\n", + "K5III 18\n", + "B8Ia 17\n", + "Name: count, dtype: int64\n" + ] + } + ], + "source": [ + "# =========================================================\n", + "# CONTAR ESTRELLAS POR CLASE ESPECTRAL\n", + "# =========================================================\n", + "\n", + "print(\"Cantidad de estrellas por clase espectral:\")\n", + "print(stars[\"Spectral Class\"].value_counts())" + ] + }, + { + "cell_type": "markdown", + "id": "f5189509", + "metadata": {}, + "source": [ + "# Promedio A7V usando for" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "0b8e882d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Temperatura promedio de estrellas A7V:\n", + "7550.178312906775\n" + ] + } + ], + "source": [ + "# =========================================================\n", + "# TEMPERATURA MEDIA DE A7V USANDO CICLO FOR\n", + "# =========================================================\n", + "\n", + "stars_a7v = stars[stars[\"Spectral Class\"] == \"A7V\"]\n", + "\n", + "suma_temperaturas = 0\n", + "contador = 0\n", + "\n", + "for temperatura in stars_a7v[\"Temperature (K)\"]:\n", + " suma_temperaturas += temperatura\n", + " contador += 1\n", + "\n", + "promedio_a7v = suma_temperaturas / contador\n", + "\n", + "print(\"Temperatura promedio de estrellas A7V:\")\n", + "print(promedio_a7v)" + ] + }, + { + "cell_type": "markdown", + "id": "64eba3ff", + "metadata": {}, + "source": [ + "# Groupby" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "5babbbe5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Promedio de temperatura por clase espectral:\n", + "Spectral Class\n", + "A0V 9607.458129\n", + "A1V 10136.022204\n", + "A2Ia 8516.840653\n", + "A3V 8584.693288\n", + "A7V 7550.178313\n", + "A9II 7349.223744\n", + "B0.5IV 28001.166630\n", + "B0Ia 27502.303666\n", + "B1III 25001.131122\n", + "B1III-IV 25403.170510\n", + "B2III 22600.139741\n", + "B6Vep 15003.610593\n", + "B7V 12462.119029\n", + "B8Ia 12092.293145\n", + "F5IV-V 6520.419327\n", + "F7Ib 6020.393400\n", + "G2V 5797.996506\n", + "G8III 4939.733287\n", + "K1.5III 4280.090548\n", + "K1V 5261.645715\n", + "K5III 3923.614977\n", + "M1.5Iab 3499.130207\n", + "M2.1V 3408.914115\n", + "M2Iab 3502.196868\n", + "M3.5V 2802.627176\n", + "M4Ve 3136.076002\n", + "M6V 2795.196060\n", + "M7IIIe 2914.515688\n", + "Name: Temperature (K), dtype: float64\n", + "\n", + "Comparación con el cálculo manual de A7V:\n", + "Promedio manual A7V: 7550.178312906775\n", + "Promedio con groupby A7V:\n", + "7550.178312906777\n" + ] + } + ], + "source": [ + "# =========================================================\n", + "# TEMPERATURA PROMEDIO POR CLASE USANDO GROUPBY\n", + "# =========================================================\n", + "\n", + "promedios_por_clase = stars.groupby(\"Spectral Class\")[\"Temperature (K)\"].mean()\n", + "\n", + "print(\"Promedio de temperatura por clase espectral:\")\n", + "print(promedios_por_clase)\n", + "\n", + "print(\"\\nComparación con el cálculo manual de A7V:\")\n", + "print(\"Promedio manual A7V:\", promedio_a7v)\n", + "print(\"Promedio con groupby A7V:\")\n", + "print(promedios_por_clase[\"A7V\"])" + ] + }, + { + "cell_type": "markdown", + "id": "6a761d45", + "metadata": {}, + "source": [ + "# Estadísticas NumPy" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "0cdc03c4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Media de temperaturas: 9983.486778663919\n", + "Mediana de temperaturas: 7379.00797517653\n", + "Desviación estándar: 7903.019053162096\n" + ] + } + ], + "source": [ + "# =========================================================\n", + "# ESTADÍSTICAS CON NUMPY\n", + "# =========================================================\n", + "\n", + "temperaturas = stars[\"Temperature (K)\"].values\n", + "\n", + "media_temp = np.mean(temperaturas)\n", + "mediana_temp = np.median(temperaturas)\n", + "std_temp = np.std(temperaturas)\n", + "\n", + "print(\"Media de temperaturas:\", media_temp)\n", + "print(\"Mediana de temperaturas:\", mediana_temp)\n", + "print(\"Desviación estándar:\", std_temp)" + ] + }, + { + "cell_type": "markdown", + "id": "11d2a681", + "metadata": {}, + "source": [ + "# Percentiles" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "f3a8e8ea", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Percentil 25: 1.664479197594917\n", + "Percentil 50: 5.845443555115757\n", + "Percentil 75: 33.71977798607205\n", + "Percentil 90: 369.92670005634596\n" + ] + } + ], + "source": [ + "# =========================================================\n", + "# PERCENTILES DEL RADIO ESTELAR\n", + "# =========================================================\n", + "\n", + "radios = stars[\"Radius (R/Ro)\"].values\n", + "\n", + "percentiles = np.percentile(radios, [25, 50, 75, 90])\n", + "\n", + "print(\"Percentil 25:\", percentiles[0])\n", + "print(\"Percentil 50:\", percentiles[1])\n", + "print(\"Percentil 75:\", percentiles[2])\n", + "print(\"Percentil 90:\", percentiles[3])" + ] + }, + { + "cell_type": "markdown", + "id": "a6789ad1", + "metadata": {}, + "source": [ + "# Gráfica de barras" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "b30cf522", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# =========================================================\n", + "# GRÁFICA DE BARRAS\n", + "# =========================================================\n", + "\n", + "conteo_clases = stars[\"Spectral Class\"].value_counts()\n", + "\n", + "plt.figure(figsize=(12, 6))\n", + "\n", + "conteo_clases.plot(kind=\"bar\")\n", + "\n", + "plt.title(\"Cantidad de estrellas por clase espectral\")\n", + "plt.xlabel(\"Clase espectral\")\n", + "plt.ylabel(\"Cantidad\")\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "b62dba29", + "metadata": {}, + "source": [ + "# Boxplot" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "056ac64d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# =========================================================\n", + "# BOXPLOT\n", + "# =========================================================\n", + "\n", + "plt.figure(figsize=(14, 6))\n", + "\n", + "sns.boxplot(\n", + " data=stars,\n", + " x=\"Spectral Class\",\n", + " y=\"Temperature (K)\"\n", + ")\n", + "\n", + "plt.xticks(rotation=90)\n", + "\n", + "plt.title(\"Distribución de temperatura por clase espectral\")\n", + "plt.xlabel(\"Clase espectral\")\n", + "plt.ylabel(\"Temperatura (K)\")\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "e1438c1c", + "metadata": {}, + "source": [ + "# Scatter plot" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "9e665370", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# =========================================================\n", + "# SCATTER PLOT\n", + "# =========================================================\n", + "\n", + "plt.figure(figsize=(10, 6))\n", + "\n", + "sns.scatterplot(\n", + " data=stars,\n", + " x=\"Temperature (K)\",\n", + " y=\"Luminosity (L/Lo)\",\n", + " hue=\"Spectral Class\"\n", + ")\n", + "\n", + "plt.yscale(\"log\")\n", + "\n", + "plt.title(\"Temperatura vs Luminosidad\")\n", + "plt.xlabel(\"Temperatura (K)\")\n", + "plt.ylabel(\"Luminosidad (L/Lo)\")\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "5de92d78", + "metadata": {}, + "source": [ + "# Diagrama Hertzsprung-Russell" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "7027390d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# =========================================================\n", + "# DIAGRAMA HERTZSPRUNG-RUSSELL\n", + "# =========================================================\n", + "\n", + "plt.figure(figsize=(10, 6))\n", + "\n", + "sns.scatterplot(\n", + " data=stars,\n", + " x=\"Temperature (K)\",\n", + " y=\"Luminosity (L/Lo)\",\n", + " hue=\"Spectral Class\"\n", + ")\n", + "\n", + "plt.xscale(\"log\")\n", + "plt.yscale(\"log\")\n", + "\n", + "plt.gca().invert_xaxis()\n", + "\n", + "plt.title(\"Diagrama Hertzsprung-Russell\")\n", + "plt.xlabel(\"Temperatura (K)\")\n", + "plt.ylabel(\"Luminosidad (L/Lo)\")\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "98b6a2bc", + "metadata": {}, + "source": [ + "# Array NumPy" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "d93c7008", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# =========================================================\n", + "# EXTRAER ARRAY NUMPY\n", + "# =========================================================\n", + "\n", + "temperaturas = stars[\"Temperature (K)\"].values\n", + "\n", + "print(type(temperaturas))" + ] + }, + { + "cell_type": "markdown", + "id": "1755fbcd", + "metadata": {}, + "source": [ + "# Estadísticas finales" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "eadd8597", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Media: 9983.486778663919\n", + "Mediana: 7379.00797517653\n", + "Desviación estándar: 7903.019053162096\n" + ] + } + ], + "source": [ + "# =========================================================\n", + "# MEDIA, MEDIANA Y DESVIACIÓN ESTÁNDAR\n", + "# =========================================================\n", + "\n", + "media = np.mean(temperaturas)\n", + "mediana = np.median(temperaturas)\n", + "std = np.std(temperaturas)\n", + "\n", + "print(\"Media:\", media)\n", + "print(\"Mediana:\", mediana)\n", + "print(\"Desviación estándar:\", std)" + ] + }, + { + "cell_type": "markdown", + "id": "551a5351", + "metadata": {}, + "source": [ + "# Percentiles finales" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "7507a40c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Percentil 25: 1.664479197594917\n", + "Percentil 50: 5.845443555115757\n", + "Percentil 75: 33.71977798607205\n", + "Percentil 90: 369.92670005634596\n" + ] + } + ], + "source": [ + "# =========================================================\n", + "# PERCENTILES DEL RADIO ESTELAR\n", + "# =========================================================\n", + "\n", + "radios = stars[\"Radius (R/Ro)\"].values\n", + "\n", + "p25 = np.percentile(radios, 25)\n", + "p50 = np.percentile(radios, 50)\n", + "p75 = np.percentile(radios, 75)\n", + "p90 = np.percentile(radios, 90)\n", + "\n", + "print(\"Percentil 25:\", p25)\n", + "print(\"Percentil 50:\", p50)\n", + "print(\"Percentil 75:\", p75)\n", + "print(\"Percentil 90:\", p90)" + ] + }, + { + "cell_type": "markdown", + "id": "eca253f0", + "metadata": {}, + "source": [ + "# Kelvin a Celsius" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "a2f9c007", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Primeras temperaturas en Celsius:\n", + "[ 7236.14424736 8230.13479643 2892.80963924 5775.17691476\n", + " 2857.45206924 9630.82170375 8268.04535514 4706.34246209\n", + " 4634.62954887 22300.1361772 ]\n" + ] + } + ], + "source": [ + "# =========================================================\n", + "# CONVERSIÓN DE KELVIN A CELSIUS\n", + "# =========================================================\n", + "\n", + "celsius = temperaturas - 273.15\n", + "\n", + "print(\"Primeras temperaturas en Celsius:\")\n", + "print(celsius[:10])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2a1f71b7-87e1-4ed6-a540-3fcb5518a04f", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/practicas/python/analisis_datos/notebooks/practica_analisis_datos (1).pdf b/practicas/python/analisis_datos/notebooks/practica_analisis_datos (1).pdf new file mode 100644 index 0000000..e6c7e11 Binary files /dev/null and b/practicas/python/analisis_datos/notebooks/practica_analisis_datos (1).pdf differ diff --git a/practicas/python/analisis_datos/notebooks/star_dataset.csv b/practicas/python/analisis_datos/notebooks/star_dataset.csv new file mode 100644 index 0000000..a6ba6ab --- /dev/null +++ b/practicas/python/analisis_datos/notebooks/star_dataset.csv @@ -0,0 +1,1001 @@ +Name,Distance (ly),Luminosity (L/Lo),Radius (R/Ro),Temperature (K),Spectral Class +Altair,16.59417123707501,9.979192445462427,1.6326504020392336,7509.2942473638805,A7V +Deneb,2600.4907228269035,196002.62785575088,202.970526216013,8503.284796430231,A2Ia +Barnard's Star,6.052616358474774,4.893715684187678,0.22271101197217258,3165.9596392449016,M4Ve +Polaris,322.6010015236985,2196.241933606857,37.546813013740554,6048.326914763769,F7Ib +Barnard's Star,5.902391663373468,-1.4964862523273919,0.1923594077740656,3130.6020692351385,M4Ve +Sirius,8.370045208990435,25.62536254052454,1.7376163136938274,9903.971703749557,A1V +Fomalhaut,25.42303189349805,19.314803198342823,1.7634732970155798,8541.195355142636,A3V +Capella,42.56957816453575,77.46654686278187,12.015077077611398,4979.492462093153,G8III +Capella,43.260858866113374,76.75397466518646,11.926446347832353,4907.779548870081,G8III +Bellatrix,239.86410710431278,6399.344000391582,5.751378540226974,22573.286177203267,B2III +Castor,51.57021005818902,59.93364175572123,2.317294377415115,10334.140338882178,A1V +Altair,16.324631801826886,10.45707878952248,1.6385681357721884,7554.538238404283,A7V +Bellatrix,240.396008875072,6396.460553762988,5.702796835694758,22559.156170298847,B2III +Hadar,349.6510239295208,49995.691816097984,9.029686061904163,24977.138850418167,B1III +Betelgeuse,642.4036425044302,125997.20910038544,886.9436673356928,3472.6066444708454,M2Iab +Regulus,79.14834001968553,290.3679076360734,3.105720387017622,12478.930088621566,B7V +Regulus,78.8696975851003,292.77713927994625,3.2154445654455555,12493.540087369223,B7V +Mira,418.3541533597022,8700.111885115977,369.94647200932155,2929.214904446191,M7IIIe +Acrux,320.95215250850816,24995.853352250557,8.476536987947346,28016.58055121632,B0.5IV +Vega,25.40728672741662,45.02639994513558,2.3758185019255906,9589.720331802691,A0V +Betelgeuse,642.4501483192605,125997.82193788076,887.023713575872,3502.8036495770207,M2Iab +Lalande 21185,8.78389229917336,0.9306154071042486,0.36997218014157396,3420.0741335824846,M2.1V +Hadar,350.3393282903268,50002.885000950024,9.030531083873981,24972.4633828412,B1III +Regulus,79.23841041664882,283.3313068914609,3.1941978242994673,12471.609230270555,B7V +Regulus,78.51275351482992,289.1046797165257,3.093785398680339,12469.726650284285,B7V +Bellatrix,239.75802627864445,6402.532053023128,5.807903991855439,22628.845403711555,B2III +Sirius,8.997561546118135,27.612290603452433,1.7178118641359001,9965.640231971809,A1V +Arcturus,36.39116253215857,169.47569492442693,25.34766748214963,4306.771078623507,K1.5III +Alpha Centauri B,3.9259386007692,-2.5124238815560895,0.8971557531469336,5292.710091689776,K1V +Ross 154,9.584936005981074,-0.2622128873565414,0.09815009889642284,2788.6078755716367,M3.5V +Betelgeuse,642.1986705590544,125995.18267169305,887.0568849865539,3502.1107945651283,M2Iab +Sirius,8.790939416886154,29.685053444507503,1.778145234597857,9959.636695100216,A1V +Altair,16.97783483438638,8.978258642897934,1.6817677393535218,7546.77607407146,A7V +Regulus,79.37549284128201,287.2472405244145,3.0775092724640816,12466.383842658091,B7V +Lalande 21185,7.922999488356227,2.681120395944034,0.46518759639849927,3394.5169092653987,M2.1V +Canopus,309.65595488089645,10500.304364175136,70.9940908831198,7322.086648344391,A9II +Procyon,11.361710078531987,11.09891870112007,2.1252624415131467,6522.987352867349,F5IV-V +Capella,43.239838363858276,78.47758735453107,12.04168320043013,4903.922634597786,G8III +Barnard's Star,6.274309005192113,-4.612503609841812,0.27142011745919525,3164.7134904158015,M4Ve +Arcturus,36.23014602060893,167.67967953475542,25.372980607290035,4285.208656712724,K1.5III +Canopus,309.89434307337245,10497.613821111012,70.98540952072986,7395.822565906416,A9II +Altair,16.481723812762002,10.654505105436737,1.6979772339329253,7557.224465410894,A7V +Polaris,323.4890826975579,2197.4846549730764,37.5928890041696,6003.417411946257,F7Ib +Barnard's Star,6.210116619871699,3.922475110995184,0.20022109890664536,3104.152562146686,M4Ve +Castor,52.3208563941243,52.46460236565418,2.3580848977347673,10286.21254520186,A1V +Castor,51.687127344898485,57.564078324527344,2.4793370398018366,10314.20142645494,A1V +Bellatrix,240.3505524329565,6403.480526616087,5.803192364925976,22632.467298684776,B2III +Polaris,323.4772161689265,2202.925953103468,37.430399789571695,5986.795558342898,F7Ib +Castor,52.31788545862922,54.098680128048926,2.3832137598247782,10264.67768772168,A1V +Barnard's Star,5.5635565189978085,-3.4589548280686215,0.14953611720828194,3115.0666806206127,M4Ve +Vega,25.02265608280089,43.21333423901169,2.4233371866214184,9631.823941413108,A0V +Wolf 359,8.040322484690764,3.518164733709185,0.2159582033041309,2786.809004459221,M6V +Regulus,79.457885087804,284.3075843561486,3.1848771847975916,12429.346874442883,B7V +Polaris,322.7090337593032,2201.1895342191797,37.558280857740726,5986.9294428280555,F7Ib +Antares,549.8094446057289,10004.888893429817,679.9451981136416,3503.22033874066,M1.5Iab +Regulus,78.84980314077531,283.1518425898611,3.1746164987628713,12414.98856094767,B7V +Acrux,320.53588050006994,25000.424960003416,8.30013131527051,27969.950394242773,B0.5IV +Alnilam,1999.5922378259786,53697.14296034396,32.48838765422113,27489.295431556606,B0Ia +Bellatrix,239.79573031543998,6401.125654435876,5.829045687901594,22632.624354404084,B2III +Hadar,349.8378240849879,50002.534526391784,8.94744777918556,25006.352397614006,B1III +Rigil Kentaurus,4.039455513108716,0.2620564024777934,1.3098243183774203,5823.975302815448,G2V +Vega,25.32510113537497,44.01956664255118,2.338790440069123,9648.560925173246,A0V +Alnilam,2000.3720438244097,53702.88073058354,32.357275804804594,27504.394522638224,B0Ia +Ross 154,9.93913784187845,-3.6471413928808327,0.23960331933197554,2767.195283308996,M3.5V +Vega,24.53113047299527,38.00891382001232,2.4294754005156816,9615.603301550884,A0V +Alnilam,2000.4789929236533,53701.23908573748,32.473046207098115,27463.288997937103,B0Ia +Castor,51.78867651717732,57.40613996148579,2.4323768195012194,10276.929953106777,A1V +Betelgeuse,642.1530702565499,126000.10150499652,886.9045632911253,3462.1435724115922,M2Iab +Alnilam,1999.880482110407,53695.72165124452,32.35326480955992,27490.40560120546,B0Ia +Bellatrix,240.30865829394963,6398.706399629343,5.727504552499588,22561.66109433901,B2III +Hadar,349.98072783140907,50000.69303998948,8.940299046830283,25043.812798420327,B1III +Barnard's Star,6.102187239521027,-0.6905551570802375,0.2265784314346753,3158.9781846800365,M4Ve +Barnard's Star,6.098594827311291,-3.3303098730228937,0.12291605693194557,3144.711153515979,M4Ve +Spica,250.4596817064251,21996.281907685272,7.481964414843237,25371.671565613717,B1III-IV +Deneb,2600.219144334045,195996.44277808978,203.09713635797436,8512.606175957664,A2Ia +Bellatrix,239.80471588472972,6400.473393470613,5.678484912182976,22628.27195885336,B2III +Fomalhaut,25.040609497955693,20.8052240111299,1.8933606922604622,8570.329145806458,A3V +Rigil Kentaurus,4.0542023166505174,5.3173565377787355,1.1417731281419847,5802.341326578711,G2V +Vega,25.145088627017778,35.23872230380841,2.3238256403915494,9614.217107611483,A0V +Canopus,309.5332875345678,10502.614219521176,71.06798014581466,7323.458433377934,A9II +Ross 154,9.61921476063749,-3.572031571628307,0.0978087615313327,2796.4035456819356,M3.5V +Betelgeuse,642.0262242230878,125998.59509722542,886.939182195466,3543.743725665777,M2Iab +Altair,17.004752557357463,15.509653584166163,1.5741356101164594,7589.01886160571,A7V +Procyon,10.930399214053109,8.573241191737985,1.9730986292291883,6548.089233804079,F5IV-V +Betelgeuse,642.1523114825334,125996.07898971764,886.9540167980291,3465.584906649717,M2Iab +Sirius,8.40488504234644,30.363211555162465,1.6975503190465253,9929.197486761122,A1V +Hadar,349.89703894408365,50003.29860598514,9.072118415520334,25020.059682136376,B1III +Arcturus,36.55940961200518,173.1186537350129,25.327584506221395,4293.232149954749,K1.5III +Ross 154,9.762760206254507,-0.22596537315790627,0.10437345974328288,2771.1757655682736,M3.5V +Alnilam,2000.4968087684344,53700.915273161765,32.32831679585277,27522.876506962413,B0Ia +Lalande 21185,8.539132551448054,-1.0184094871245468,0.3484419457491451,3396.2390187861406,M2.1V +Polaris,322.7829657396212,2197.4579935613187,37.56516587074775,6063.924563018583,F7Ib +Deneb,2599.541671531891,195998.9041368802,202.92157091325018,8503.08100456294,A2Ia +Vega,24.959311232910533,38.236535117812586,2.2955242719863977,9650.454657524815,A0V +Acrux,321.3978818285302,25002.451304950046,8.40073431108804,28000.481701856206,B0.5IV +Spica,250.3496408249325,22004.59479708713,7.48705009677652,25392.535590103464,B1III-IV +Capella,42.98764050809396,80.53611367039014,11.928552734356183,4936.351352278644,G8III +Altair,16.790538913857493,7.001586190285418,1.6190056898410539,7500.178549124861,A7V +Antares,550.3341533847138,9997.61131020143,680.029117220661,3516.839353089165,M1.5Iab +Capella,42.80414644083066,77.7419793077256,12.028719516305973,4937.014499217616,G8III +Wolf 359,7.987098773049044,-4.9033579226853,0.25746878785429467,2800.610804893218,M6V +Spica,250.1853696897831,22002.94677024924,7.329968093356848,25440.0209321473,B1III-IV +Acrux,320.5863393634801,24997.637919736644,8.310447834832418,27989.401366565075,B0.5IV +Mira,418.21532323512395,8697.78504078488,369.95011289757565,2955.942150604245,M7IIIe +Altair,17.114041468810747,7.967577662722815,1.6666693118467406,7589.938436857879,A7V +Betelgeuse,642.4002182709401,125995.07325895016,887.0102958691334,3481.0895756208192,M2Iab +Barnard's Star,6.066146574141507,-4.202962127667188,0.18560290038694682,3157.0629115253996,M4Ve +Achernar,144.41347739924058,3145.670632301648,9.151738144396306,14986.331180964033,B6Vep +Aldebaran,65.1820343113461,515.388476668136,44.22384644093751,3907.5149974842684,K5III +Antares,550.2111451274665,9999.116102372378,679.9672994027036,3549.315194904685,M1.5Iab +Hadar,349.8618670626462,50004.94895125297,8.924915431984006,24982.455998433135,B1III +Arcturus,36.66414022992508,171.1056762518648,25.322341069807717,4254.144469573005,K1.5III +Aldebaran,64.86663507615103,516.5412218579359,44.14298534438638,3892.8923877416173,K5III +Regulus,78.6610515633756,286.1262199301582,3.1039473513253473,12455.978660537863,B7V +Lalande 21185,8.389619801046,-1.6420207674531937,0.2917824459123116,3439.2127163789055,M2.1V +Canopus,310.30248789941453,10501.328054061814,70.99461190714392,7352.700290205437,A9II +Canopus,310.1123839470811,10496.34418086692,70.93894825544076,7392.756918098973,A9II +Acrux,321.1642531708573,25001.97379001607,8.476967513522574,28002.686917940457,B0.5IV +Sirius,8.178965638409595,23.018882776264523,1.6429830796078737,9961.260787473504,A1V +Canopus,310.4339221913486,10500.701090322545,71.07120441889143,7343.565554910746,A9II +Rigil Kentaurus,4.107727284195991,2.0465447810028436,1.1342043679791856,5799.58379279055,G2V +Rigil Kentaurus,4.402094885920716,3.255888946307942,1.1325926429277804,5784.487491811251,G2V +Sirius,9.003723782469484,25.31721426439794,1.7682429170729694,9945.938898140306,A1V +Barnard's Star,5.77531813296572,-1.9476137463014966,0.18516435027980302,3100.1967912356345,M4Ve +Polaris,322.69367242714384,2203.214692898426,37.58057570411819,5973.267626537678,F7Ib +Spica,249.71633706178963,22000.712538786633,7.4530069804035035,25382.54424773179,B1III-IV +Spica,249.7559118255533,21997.467782210406,7.403967800257108,25413.23854342704,B1III-IV +Procyon,11.548017997505934,11.179783704362094,2.0768331643377036,6532.552150833123,F5IV-V +Acrux,320.68121543300316,24999.998219227884,8.331568002897049,27976.048166346933,B0.5IV +Antares,550.0925105716918,9997.105346601093,679.9637801969628,3462.614891178801,M1.5Iab +Rigil Kentaurus,3.9786325410020655,-2.119236183448141,1.154587336979579,5743.193545774129,G2V +Vega,25.47379567716754,41.94883657141961,2.2836267337545935,9636.2663929921,A0V +Barnard's Star,5.503354374007524,-1.4261367429859866,0.19373771952839025,3138.143529653492,M4Ve +Aldebaran,65.27837547917696,516.7874159559605,44.19667580773142,3891.6958488395844,K5III +Alpha Centauri B,3.9962177138878325,-2.5988815711687474,0.883037871335775,5231.122023964701,K1V +Canopus,310.2691827891006,10496.17932647521,71.09609603499091,7379.760016569846,A9II +Castor,51.78765008596086,52.55239172717802,2.377917302214843,10339.144211828336,A1V +Rigil Kentaurus,4.088694603367449,0.30507316365590653,1.159697069308526,5815.131546667408,G2V +Aldebaran,64.5902948982921,519.3372320256896,44.26426716265437,3916.6136134918343,K5III +Altair,16.342681874475897,14.591181440400177,1.6839372242618915,7534.755587192668,A7V +Arcturus,36.246122455758346,165.8219515674998,25.435121407803933,4263.974299475472,K1.5III +Fomalhaut,24.739227835351564,12.761776780006507,1.8660325221773046,8587.326514897997,A3V +Antares,549.6020841306806,10003.583240374617,680.0178309194273,3515.0718020662684,M1.5Iab +Hadar,349.85840398022134,49998.71828587879,8.997233568702034,24979.30083017181,B1III +Deneb,2600.3849852172243,195997.22402582658,203.01037378760626,8495.072256076804,A2Ia +Vega,25.021842852433267,44.096087879563065,2.3915187386743293,9644.280857167912,A0V +Aldebaran,65.0148671399861,520.8330693802092,44.14048104822591,3930.7677184114414,K5III +Acrux,321.0192431558176,24999.47677803858,8.466934582648141,28044.279271635794,B0.5IV +Altair,16.515550441516513,7.453787627075437,1.5490210975388299,7579.282835765471,A7V +Polaris,323.18740651993204,2195.0085355638607,37.413948981624834,6023.522561426781,F7Ib +Capella,42.66191607008856,80.31893393586179,12.053892691975884,4980.589604549405,G8III +Sirius,8.42964716497559,28.766218323597716,1.6216854840949964,9914.722343392266,A1V +Rigel,859.8736693721206,119998.91159177457,78.84757027028947,12090.984442603067,B8Ia +Alnilam,2000.254556921467,53704.6457106366,32.48379461686017,27523.886823836907,B0Ia +Aldebaran,65.12504717981578,513.8024725995764,44.133137893565376,3937.1366939387976,K5III +Mira,417.73968452269605,8702.983016446178,370.0558584338656,2923.256810517708,M7IIIe +Ross 154,9.457219736836048,3.5558108313769368,0.16738653049763086,2757.8244007742705,M3.5V +Fomalhaut,24.94774315643359,19.078458000505698,1.7827045212416661,8578.83278985885,A3V +Mira,418.4800274472216,8699.413953474097,369.91940220002334,2882.169873058536,M7IIIe +Alnilam,1999.9722500667908,53695.46342027454,32.318443183674674,27519.496419622923,B0Ia +Betelgeuse,642.4314171166554,126001.74686159294,886.9717142807095,3460.211471007395,M2Iab +Procyon,11.232801031989052,11.483008311297528,2.0354606049471995,6531.580696599702,F5IV-V +Mira,417.96038900748766,8697.873320471392,369.9027391626386,2922.151960877924,M7IIIe +Sirius,8.97905760209878,24.461618038155763,1.6208975551577192,9949.850807441388,A1V +Hadar,350.1211769454686,49995.72669531548,9.02310133825602,25047.364915414353,B1III +Procyon,11.734879069041147,11.03453099609397,1.991069283038106,6531.624256212896,F5IV-V +Altair,16.650909255277465,13.984383744732718,1.5937402895793085,7547.85329895543,A7V +Acrux,321.1982673917823,25004.094559395624,8.349207390972214,27983.088895885925,B0.5IV +Alnilam,2000.344809422834,53697.71750208001,32.31687443184585,27454.23278263376,B0Ia +Spica,250.29130895484806,21998.65350042777,7.317585768709005,25365.343642668537,B1III-IV +Spica,249.83597944955196,21995.249403313665,7.30748784703254,25374.52380217647,B1III-IV +Spica,249.6956810552482,21999.44025694579,7.460858219786576,25426.059434160332,B1III-IV +Alpha Centauri B,4.661465963884386,3.6839683429692047,0.8928876028714727,5220.886580357062,K1V +Lalande 21185,8.657942790455385,1.5570754937375668,0.3707991662282603,3415.93622768099,M2.1V +Deneb,2600.203153160722,196001.99383714548,202.99286280603295,8495.151612981792,A2Ia +Acrux,321.12567330882814,24995.384020357043,8.442727449870432,27978.616899027686,B0.5IV +Spica,250.40575521554814,22003.006083358974,7.390872002597096,25449.71317458375,B1III-IV +Altair,16.90978103577815,5.93326550747497,1.6968367572893808,7581.485620502184,A7V +Achernar,143.92295573741418,3151.3800629399616,9.119515925724818,14989.956949574469,B6Vep +Alnilam,1999.9054768769838,53698.01063562469,32.480678048563625,27457.356767249177,B0Ia +Canopus,310.25752765758386,10500.535791916333,71.05510034800109,7303.50967447793,A9II +Regulus,78.60906106487893,291.3198765189602,3.2265577133066277,12501.522893637833,B7V +Capella,42.90883268003728,81.73207831773567,11.95953655943859,4987.631565952726,G8III +Rigil Kentaurus,4.00631598035014,4.719480891220876,1.2336490462319623,5806.306504209014,G2V +Altair,16.673538512166857,11.923057499670024,1.5699737742172752,7536.608049164217,A7V +Deneb,2600.054111698248,196004.85408062232,203.02271485552896,8502.296032890257,A2Ia +Betelgeuse,642.7132328379636,126004.80652062806,887.0593271335669,3536.7368905754315,M2Iab +Betelgeuse,642.9734496672988,126004.17804606361,886.9783661577184,3499.5535257170536,M2Iab +Sirius,8.910964990477838,27.883155142457618,1.7900438700764771,9937.999676579542,A1V +Alpha Centauri B,4.191178428095684,-0.19486962752822584,0.8756903221903196,5265.168219988585,K1V +Bellatrix,239.74665869272962,6400.045563495309,5.79273451209337,22596.63758448558,B2III +Lalande 21185,8.600332846394044,4.389365061208859,0.3263580201334272,3446.85565285417,M2.1V +Acrux,320.74846067676384,24999.882212098993,8.314309807986174,28023.155964798407,B0.5IV +Hadar,349.54803179030006,50003.437434998974,8.905896631554882,24972.673323377327,B1III +Polaris,323.2942868029988,2197.3393508229037,37.5741331642113,6052.715168871659,F7Ib +Altair,17.031047210189243,9.420447881017374,1.5648288866042455,7556.190476558557,A7V +Acrux,321.0172738889805,25000.175523659404,8.36681531774404,28020.75528329591,B0.5IV +Polaris,322.63039128938027,2202.3045046501984,37.450291693135405,6035.256993173695,F7Ib +Capella,42.42640506726292,78.6261618921119,11.92288120798912,4945.1586956174515,G8III +Polaris,323.25830287505704,2203.005803953794,37.53316120937322,6007.279091506018,F7Ib +Bellatrix,240.11729164012903,6401.703522703113,5.712638150016882,22610.104644796527,B2III +Altair,16.334612838722375,5.9053618375212995,1.585493732123344,7543.984771238739,A7V +Spica,249.95600945257033,21997.27514055534,7.485745901146536,25412.277818674906,B1III-IV +Vega,24.796722904603456,38.83227073761078,2.2863451208184915,9558.280287121293,A0V +Arcturus,37.0649256344522,169.13451268871574,25.374591218678557,4262.121427943406,K1.5III +Castor,51.657170460932534,59.20488222648442,2.357942572148126,10292.861659151447,A1V +Alpha Centauri B,4.604116282070338,4.336677893186863,0.8123240933578639,5230.1800654952885,K1V +Procyon,11.811384418414272,5.556790524669831,2.070303770670327,6555.208745181177,F5IV-V +Betelgeuse,642.6457930899971,125998.30283452646,886.9683219489082,3536.3317895746136,M2Iab +Lalande 21185,8.552871356637239,3.3547011813311096,0.3359750207028117,3385.261827154311,M2.1V +Hadar,349.70525337779173,50004.815878851376,9.058875243596658,25045.681712395777,B1III +Rigel,860.3299817159254,119999.15795806011,78.95886969049536,12124.52692305495,B8Ia +Alnilam,2000.2311498588906,53703.68232367893,32.37988024091837,27531.724512773984,B0Ia +Wolf 359,8.117918695659103,0.24450376398123416,0.08813317525933075,2763.1290458119993,M6V +Altair,17.126532940989705,13.81675388246157,1.565304550524819,7539.0160871515645,A7V +Altair,16.841284457536943,7.6601003734060775,1.6669078313100163,7596.29125205924,A7V +Regulus,79.46905039034043,291.53808793659346,3.1693667465692688,12485.81487661987,B7V +Achernar,143.96369643781577,3153.448869022427,9.122215036720787,14983.057034916466,B6Vep +Altair,16.73976423176716,14.245027690727097,1.665819170309692,7582.813277293578,A7V +Castor,52.33739487109884,52.38529121936184,2.367909461519737,10332.886399058902,A1V +Ross 154,10.114346873131268,-1.8722454742468062,0.20208478365559165,2826.6630933667043,M3.5V +Polaris,322.502155570597,2203.051863296195,37.46675410216605,6014.489149122259,F7Ib +Arcturus,36.501673392977565,165.95913679819427,25.45174904528886,4305.298558387129,K1.5III +Aldebaran,64.9102918076204,515.8831436751786,44.20349553455149,3941.025871305458,K5III +Antares,550.0793115802902,9998.673327093757,679.9796032077534,3495.8089900134005,M1.5Iab +Ross 154,9.48114273199893,1.5629475832181847,0.26290790952216525,2842.720811632883,M3.5V +Lalande 21185,8.326995952783522,-3.116117283278311,0.39766711699356744,3425.2194804264423,M2.1V +Capella,43.18977231526731,78.15928520691827,11.953867400157446,4910.84162406762,G8III +Rigil Kentaurus,4.684740783845968,0.4820732837390491,1.250155333192906,5790.563085966682,G2V +Hadar,349.9265432643831,49997.88363907442,9.083568824870753,25014.23536538512,B1III +Procyon,11.853186614150347,4.568259386078665,2.0789873441417757,6529.710106429497,F5IV-V +Bellatrix,240.38937400299514,6400.6876528621815,5.771479476204662,22641.471075444053,B2III +Rigel,860.351094890128,120000.67143455558,78.97709526344825,12107.15853245105,B8Ia +Capella,42.62172687540109,82.18179589209237,11.941025047642833,4961.113619150101,G8III +Canopus,309.85247308584013,10495.295032892276,70.99857709558052,7374.061556326981,A9II +Arcturus,36.60944251909364,166.92216610675578,25.322127050604966,4246.36678371611,K1.5III +Deneb,2599.531004708632,196000.71131056777,203.08998579556487,8566.459428182321,A2Ia +Rigil Kentaurus,4.009178210050658,4.52095272104491,1.225897996978761,5743.205315695931,G2V +Alnilam,2000.0469500959857,53704.55022172194,32.42516404981663,27472.24734094678,B0Ia +Fomalhaut,25.376635374231352,15.012057956491532,1.9018628466940786,8587.252624053881,A3V +Mira,418.2183952968461,8704.780649511065,370.07442661072827,2925.39207629807,M7IIIe +Betelgeuse,642.6088452768547,126002.55580263575,886.9641939292504,3486.421808766696,M2Iab +Rigil Kentaurus,4.472942767831179,6.4969976740702755,1.1768595687999464,5809.065322818583,G2V +Barnard's Star,6.0359771357513825,2.7849267342360386,0.23446086063726881,3175.6029186098235,M4Ve +Canopus,310.2172670982593,10496.355536592739,71.0677688332974,7352.898512667379,A9II +Barnard's Star,5.46425033457099,3.1016816563223246,0.2897915498142176,3088.0600118494194,M4Ve +Polaris,322.5390777157187,2202.7485906334337,37.47237729970524,6054.799748479425,F7Ib +Ross 154,9.907428254444897,-1.7548883850025496,0.25020849799005335,2785.3038548882723,M3.5V +Regulus,78.52313741046954,287.59429416197145,3.19325928112728,12437.502387342196,B7V +Achernar,144.31905356616832,3145.0671706093503,9.150569357208825,15016.888543390136,B6Vep +Acrux,320.60318172049745,25004.818724393608,8.344046443485047,27957.206186514268,B0.5IV +Alpha Centauri B,4.233930259760326,0.9539660997456003,0.9556066517851436,5229.85412918169,K1V +Arcturus,36.4667172645417,173.39296258557283,25.351421298413634,4262.2214543702285,K1.5III +Canopus,309.5953487649189,10501.356418248894,71.02409390389981,7383.247694715101,A9II +Betelgeuse,642.8715692674214,126000.7909588918,887.0942541887144,3534.3458759812875,M2Iab +Mira,418.17093478352064,8699.459630086449,369.9191649407296,2912.8614788628884,M7IIIe +Deneb,2599.843961974584,196001.81828846314,202.9318394997477,8493.781820782286,A2Ia +Procyon,11.633141363707045,4.578402287038895,2.0471210918287834,6500.1494809750775,F5IV-V +Alnilam,2000.176215815057,53700.02445566662,32.328478244473274,27452.842914880956,B0Ia +Lalande 21185,8.16476186236918,-1.5287605534413269,0.43420345284398065,3409.3499687450135,M2.1V +Altair,16.30343825476463,9.448611058586202,1.5697965761324495,7560.184538579161,A7V +Alpha Centauri B,4.603151026770734,-1.7646167713238146,0.9363487436919333,5241.433383120412,K1V +Deneb,2600.1188300320887,196003.7348740918,203.03314552146534,8510.697414640012,A2Ia +Deneb,2599.853939051221,196002.77831016888,202.99038848268452,8517.033344067619,A2Ia +Vega,25.06659451671611,44.65672904821405,2.42044802809996,9569.505040627617,A0V +Arcturus,36.543921553843404,169.2345433964546,25.492741868464453,4243.105647278277,K1.5III +Deneb,2599.6087383328495,195999.36817978608,203.07130390051958,8502.019466565263,A2Ia +Betelgeuse,642.5531284859233,126003.277178296,887.045921394874,3513.514299267463,M2Iab +Capella,43.24996496461586,74.3084242293209,11.94513010156456,4913.438632006412,G8III +Canopus,309.75776637760686,10501.282994165453,70.93329994232798,7333.1073847363505,A9II +Wolf 359,7.4945134846058155,-0.5237519388581489,0.25076987305386367,2830.7174304554483,M6V +Mira,417.69434190620393,8695.76542169597,370.07166136037114,2917.612989328211,M7IIIe +Lalande 21185,8.268111532689437,0.4066786400028192,0.40391327021532425,3424.134208606245,M2.1V +Hadar,349.74627308407605,49999.43621440881,9.069477468347682,24977.196252884776,B1III +Castor,52.15011540693591,58.00481211390884,2.315381159248808,10252.300788503715,A1V +Betelgeuse,642.5688338268451,126001.59526536078,887.0415508127494,3523.3700224726635,M2Iab +Alpha Centauri B,3.927727273120638,2.3798778547511135,0.9533430209824598,5297.158921328318,K1V +Procyon,11.729222953510117,10.41549792084328,2.1142320530955607,6500.799566238323,F5IV-V +Polaris,322.5304351797596,2198.062243311905,37.43978024422336,6006.5384310582685,F7Ib +Altair,16.817757811872315,6.6168551339155055,1.6208417286066443,7535.477776374925,A7V +Bellatrix,239.8107170031412,6403.26717033482,5.7992031692434605,22577.65870176337,B2III +Betelgeuse,642.7606943182192,125996.53351669671,887.0894835356495,3541.5852076801953,M2Iab +Altair,16.775344887638514,13.692070293109474,1.602312150664671,7522.863573759096,A7V +Achernar,144.42696352608482,3149.043659334665,9.244538986323182,15004.67745453246,B6Vep +Hadar,350.28250752481273,50001.855266313454,8.913280385213783,25008.776305248775,B1III +Capella,43.26898110439547,83.53213620184849,12.060003732156051,4895.714239351671,G8III +Alpha Centauri B,4.500100880129606,-1.8675040449466291,0.7769871816361916,5279.807556255891,K1V +Alnilam,1999.8010468906077,53702.72472446624,32.463760926207456,27494.18077728759,B0Ia +Sirius,8.95764006062001,29.619564748597867,1.6328596476650405,9911.392753647751,A1V +Fomalhaut,25.395341516452056,20.46915048265418,1.8475953691018931,8588.479248186732,A3V +Barnard's Star,5.754938969408459,0.5782857917849586,0.18295040783606675,3110.132292246199,M4Ve +Sirius,8.22699804145759,26.254898678554593,1.7230777808471107,9956.238735550362,A1V +Wolf 359,7.573447101024423,4.928126803872541,0.18973704255580687,2812.869725284097,M6V +Acrux,320.5859634991353,25001.511998910722,8.324294583067696,27961.78016959039,B0.5IV +Regulus,79.02170301809184,290.58102691030575,3.2233778958160197,12465.249997728437,B7V +Sirius,8.581163580860268,23.56576836319067,1.6754102483016422,9936.119303434922,A1V +Castor,51.96002579241676,50.77458294296149,2.363595863350619,10343.780169200643,A1V +Capella,43.15465762520267,80.9564806125028,12.046502747044403,4890.416640335966,G8III +Hadar,350.48265904666846,49995.66255771765,8.963173673367711,25015.409494276384,B1III +Canopus,309.93058315209595,10499.156949397066,70.92521212934165,7306.052369323466,A9II +Rigil Kentaurus,4.75762801578623,0.12499315368356068,1.1474521060199832,5791.391749396839,G2V +Capella,42.647659674923545,75.85204596899882,12.091994996552842,4977.384391917685,G8III +Acrux,320.9124461243215,25003.204339520365,8.45626281869077,27970.08159580839,B0.5IV +Altair,16.962965725071445,12.700496302235546,1.5603313212736145,7527.007991164982,A7V +Lalande 21185,8.383258213157267,-0.9381894217595698,0.34721305721875617,3396.163555406511,M2.1V +Ross 154,9.979598917012972,4.882884323074658,0.18689670825937352,2801.7091492916584,M3.5V +Altair,16.305159249689783,10.12400801898782,1.699514766741106,7561.924913177847,A7V +Procyon,11.221180880093733,4.454008562762063,1.9686260827440123,6490.797977413512,F5IV-V +Altair,16.428114807916586,7.5188985941992765,1.6910536041439572,7548.1924994307965,A7V +Acrux,321.40395624936485,25001.131958554575,8.376409823466476,28024.705497539097,B0.5IV +Arcturus,36.23103318743993,172.6283509663686,25.45824500567212,4311.320939071334,K1.5III +Procyon,11.099357364573127,4.0461929323360755,2.10801567334089,6548.53488183696,F5IV-V +Hadar,349.9233971467892,50003.184457837844,9.089940136231116,25035.76929921509,B1III +Hadar,350.1548367045636,49996.93606004356,9.039185399576763,25033.689212790745,B1III +Polaris,322.93613956377834,2203.945872499883,37.526683022101565,5966.658386402887,F7Ib +Betelgeuse,642.3796736220082,126000.56704612002,887.0961516152369,3491.8362157548445,M2Iab +Altair,16.650873710554336,6.046501288662712,1.5882140757870844,7514.631409637324,A7V +Betelgeuse,642.6993191749599,126004.33011528915,886.996238330138,3482.913533547304,M2Iab +Lalande 21185,8.144854579475982,-1.4953798799163283,0.4578056842243665,3427.7908259214564,M2.1V +Capella,42.65444955623385,77.89996416831873,12.059956279582682,4953.960884388006,G8III +Achernar,144.4397778356189,3153.6198983288955,9.157460216023386,14980.806629012488,B6Vep +Alnilam,2000.0880201642992,53702.76196695219,32.36957560840282,27537.942365662122,B0Ia +Rigel,859.9824983681953,119998.62299140115,78.91303443626789,12085.710676444596,B8Ia +Castor,52.22988431306953,54.099526820783055,2.341583905473246,10293.764261845483,A1V +Hadar,349.9762351065161,49997.02136689043,9.002662918933126,24998.190819959676,B1III +Alnilam,2000.377238593158,53702.78826659873,32.340054519445154,27456.537115962084,B0Ia +Hadar,349.8025258945259,49998.0695274668,9.099062530956529,24984.25348850092,B1III +Sirius,8.650238632854773,25.384186490272075,1.6419024473267774,9981.789237855872,A1V +Rigil Kentaurus,4.142560356201541,-3.409763574323616,1.129143335844198,5837.601488919213,G2V +Fomalhaut,25.132967410517995,20.863466303473007,1.812050356154002,8573.561550669108,A3V +Fomalhaut,24.908006486525945,18.947503258018802,1.8593885820231693,8550.148653413544,A3V +Mira,417.7833122552771,8702.919445956213,369.96974684811136,2944.801066776992,M7IIIe +Procyon,11.561154029092972,11.127636055713175,1.9980519891339659,6492.727527255873,F5IV-V +Mira,418.0577769995517,8702.628165997337,369.9577872160376,2922.3529638603686,M7IIIe +Achernar,143.58377436946893,3154.0943334053554,9.28649517118028,14987.672115777534,B6Vep +Antares,550.4834100624427,9995.999324590084,680.0122219445168,3468.906853654205,M1.5Iab +Altair,16.754464460371924,5.99788943061886,1.6221541738349006,7534.314145799876,A7V +Bellatrix,239.93285610754845,6397.415458459581,5.768024266938191,22598.96932304299,B2III +Lalande 21185,8.778835112157529,0.9661196267349227,0.31173602545008877,3437.9462535855955,M2.1V +Vega,25.48267392461975,43.143004904768915,2.3781405597207295,9615.286109199222,A0V +Mira,417.9698200829036,8702.747824718203,370.031379577419,2908.9053112542947,M7IIIe +Arcturus,36.32229979885953,172.62720869691438,25.394601834434013,4334.366638619499,K1.5III +Vega,25.06973647278645,42.58073946132156,2.311884583267881,9639.90846974805,A0V +Altair,16.723699215336318,7.755495987710255,1.531232494293574,7580.000022793084,A7V +Fomalhaut,24.63695818655648,19.023124550190577,1.886319861515815,8572.460129705985,A3V +Alpha Centauri B,3.8798822553990275,0.7910473169383339,0.9139765233764823,5295.11315329918,K1V +Fomalhaut,25.291726752209044,15.472854803761287,1.771133455977071,8547.759463959905,A3V +Canopus,309.7226809100175,10504.045242465518,70.92404023319769,7325.448677329159,A9II +Altair,17.07909134160172,11.105626941079539,1.6888037073732733,7548.914114980805,A7V +Vega,24.71555489176861,37.54171812892304,2.441074106318069,9556.382225627973,A0V +Castor,52.11930609709243,56.54850720582925,2.4690420521017296,10284.861645140678,A1V +Bellatrix,239.69414728045675,6396.281240197269,5.703987995850954,22582.222074378238,B2III +Alnilam,1999.87084484106,53703.28456261201,32.37200611603363,27491.34645260905,B0Ia +Hadar,349.53181444637727,49997.805725309554,9.050848967804637,25039.836943850994,B1III +Capella,42.721731404078504,82.71423020357825,11.997265130160406,4968.613459748679,G8III +Deneb,2600.459947369687,195998.67867356437,202.94619739326748,8537.114059998905,A2Ia +Arcturus,36.72859011150761,169.17410203086075,25.496502794210354,4310.686136906374,K1.5III +Hadar,349.5763036550494,50000.28166873743,8.941387767072202,25031.53164140025,B1III +Vega,24.857542443674294,43.36477472469677,2.354470575096003,9572.998301263318,A0V +Capella,43.067128278544466,76.53137693582548,12.066827849039573,4930.415617102395,G8III +Bellatrix,239.67828048448501,6398.615400878229,5.792124898419817,22625.863115570453,B2III +Alnilam,1999.8198241830476,53704.23807043841,32.37301069146568,27476.304434992006,B0Ia +Arcturus,36.36893818169971,173.91735348449976,25.471657388242885,4242.998140186064,K1.5III +Regulus,79.38640904460017,286.9002630101488,3.1994875667376994,12428.597803875617,B7V +Altair,16.431583556207517,13.936622867381303,1.696114023366309,7562.92846623151,A7V +Achernar,144.12328599301048,3150.1765636444493,9.251943571289882,14980.639676598574,B6Vep +Capella,43.18112317773428,79.81176567485554,12.0193058060152,4926.989009107683,G8III +Betelgeuse,642.2406798816608,125995.74018464192,886.92017281221,3533.455447950868,M2Iab +Rigil Kentaurus,4.5115107589995525,5.469163180881795,1.2968123458311946,5798.583918339648,G2V +Betelgeuse,642.7086272299188,125998.15810975224,886.9146359224729,3463.7621290752586,M2Iab +Mira,417.8076208586674,8700.674611535678,370.0487981231602,2897.53935166085,M7IIIe +Alnilam,2000.37271159395,53696.713104182534,32.43314184230521,27532.91754317543,B0Ia +Fomalhaut,24.787814094086002,19.240019388477002,1.8450225960402775,8598.361346801556,A3V +Altair,16.597555199697663,9.796254335014925,1.6317932586227673,7589.59207038745,A7V +Vega,24.550546542267956,40.70030429351264,2.3421849992787616,9620.122908880237,A0V +Procyon,11.37786080726909,11.111696301057986,2.100885983527915,6567.269089990825,F5IV-V +Acrux,320.5587773374703,24999.132922504472,8.477116293130464,28043.247627927078,B0.5IV +Antares,549.6326078449839,10003.064238945663,680.0008496850047,3502.850350435827,M1.5Iab +Capella,43.36976619606791,75.6656528468021,12.030823996409744,4900.136077462795,G8III +Sirius,8.592832833642735,29.163573989960476,1.7681196500535434,9938.230274996757,A1V +Ross 154,10.082428468579502,1.1272223547577958,0.1589565493633382,2842.2825388131187,M3.5V +Canopus,310.40561001383736,10495.918760680679,70.98400527526447,7375.567457425631,A9II +Bellatrix,240.46546493984695,6397.076711841578,5.721036989086144,22561.35958472074,B2III +Arcturus,36.85515697959471,170.39260600268693,25.401557238283477,4295.448832879542,K1.5III +Canopus,310.2208988524362,10495.782502652297,70.99490029898075,7385.103212988658,A9II +Ross 154,9.509693473009362,4.593223791929575,0.2898476991164427,2793.132384849271,M3.5V +Hadar,349.7007690438944,50001.10395171099,8.976397162075818,24985.895286543746,B1III +Fomalhaut,24.93993408396935,18.708421317411393,1.8606249667543346,8543.52410709154,A3V +Vega,25.215375947746416,42.41615685855492,2.2891796676560316,9565.942046921979,A0V +Alpha Centauri B,3.8777984948209214,4.0367179142966485,0.8511027900559873,5247.639003737363,K1V +Spica,250.35860614560136,22000.991538788872,7.35447137499463,25398.0300997285,B1III-IV +Aldebaran,65.22314745573473,514.3940375429517,44.129565027617524,3884.7972406139806,K5III +Mira,418.2559404634954,8695.285930090933,369.91082905731247,2938.727954697556,M7IIIe +Vega,24.921386227437697,40.515480684043176,2.3557618374587954,9601.092538925532,A0V +Betelgeuse,642.9528733444157,126004.55672976901,886.9901081445247,3531.391606015495,M2Iab +Castor,51.63546472562079,59.035587475875595,2.3142095414554373,10335.236868041908,A1V +Rigel,860.0446487167943,119995.72802782974,78.8345977343025,12068.024249512593,B8Ia +Ross 154,9.613438425931394,-1.2141279074839573,0.2500555533323149,2809.757850999919,M3.5V +Wolf 359,7.999848244547756,2.266088270736416,0.22389523624750202,2846.28632610673,M6V +Acrux,320.88683059183285,25003.59644188548,8.472800900249295,27950.980185874738,B0.5IV +Fomalhaut,24.801334879905827,15.639550015309691,1.8909501339630872,8550.050076372288,A3V +Rigel,860.3779303884187,119998.5139278143,78.95582134736885,12056.931040199388,B8Ia +Wolf 359,7.93457653564171,-2.6993031727412533,0.09813526394231287,2818.8771744817477,M6V +Canopus,309.949279299694,10502.983510922511,70.99441217507064,7378.8673598338255,A9II +Rigil Kentaurus,4.021572470121028,4.237437376579976,1.2922529360260686,5779.19170271629,G2V +Arcturus,36.20354839373127,174.01100320067363,25.37788131476717,4257.266449388856,K1.5III +Arcturus,36.24569176751628,170.20157618905327,25.324338912297844,4238.82430741777,K1.5III +Fomalhaut,24.52798083660612,12.367104855009664,1.7564024147735555,8624.298340673686,A3V +Deneb,2599.9450011255235,195996.93639287664,203.04830518335083,8510.964916073643,A2Ia +Mira,418.2175842849551,8700.5674109947,369.97061963732,2872.35158564138,M7IIIe +Procyon,11.678427502003084,3.9393406366475836,1.9982456617599147,6532.259266094722,F5IV-V +Canopus,309.5950008995232,10500.971727121856,71.07067754606098,7313.717188692489,A9II +Wolf 359,7.692989324958735,3.1435833625883096,0.23376954268671377,2832.3101701168216,M6V +Bellatrix,240.4177991738177,6401.595201030681,5.785649927403525,22640.502541288515,B2III +Altair,16.80481859931867,10.780866248875249,1.6706060054339127,7505.6738870019035,A7V +Capella,42.524191767947265,79.236390220434,12.070355838014219,4964.310251936597,G8III +Rigil Kentaurus,4.300779447953355,2.899348455421122,1.139323498435139,5821.31848567538,G2V +Rigil Kentaurus,4.533255211906194,1.0622984187908109,1.2791079087439066,5820.542839082289,G2V +Alpha Centauri B,4.436330965784739,-2.897159041753857,0.9503195553708486,5303.062134893854,K1V +Ross 154,9.38679526791198,1.2972165822975552,0.14632184715825822,2820.4301831792127,M3.5V +Achernar,143.77764483165026,3148.316088852544,9.178283935157074,15040.7751413703,B6Vep +Ross 154,9.266675131293121,2.5676550292690377,0.2941266326790664,2816.7747126498034,M3.5V +Hadar,350.3462163095896,49997.251393633545,8.910438460017065,24972.0104980473,B1III +Rigil Kentaurus,4.558961315570268,1.5055163896454722,1.1791161113230062,5780.016587479109,G2V +Achernar,143.7208361441719,3146.1704513835157,9.258760681265409,14989.107553451975,B6Vep +Lalande 21185,8.399926954945043,4.2766464192969105,0.4579131529875583,3414.2167978418847,M2.1V +Alpha Centauri B,3.9326562057963685,-3.8018034621926975,0.8058931413102509,5215.398711764666,K1V +Arcturus,37.06140162916029,171.13842474554625,25.47301615687733,4266.187709020766,K1.5III +Barnard's Star,6.05724013797307,3.6304724097365755,0.18062082535854362,3106.2706290664537,M4Ve +Betelgeuse,642.2465107194334,126000.91426019295,886.9633557470046,3516.0947512384396,M2Iab +Altair,16.413501979632134,11.624212298411338,1.6680064880042818,7518.687343972402,A7V +Capella,43.22182719528961,80.1562183943607,12.012566699471403,4973.087375934008,G8III +Fomalhaut,25.44873361843539,13.070027808524156,1.8203217306681783,8576.37781241298,A3V +Arcturus,36.91845733608466,169.0336812528439,25.36844190590766,4318.231806821839,K1.5III +Acrux,320.65320185737164,24998.5503809941,8.30702521149024,27978.915425451105,B0.5IV +Altair,16.688705570405098,10.481825565277513,1.5409209438371902,7585.65962779586,A7V +Hadar,349.6884498607735,49999.05801525981,9.077749094064444,25025.683786434554,B1III +Spica,250.48787578507955,21999.873328203874,7.344215860984274,25435.584521920915,B1III-IV +Hadar,349.98310298123266,50000.7563298815,8.958489961994806,25032.920789852877,B1III +Mira,418.40207144643017,8699.480336707316,369.9117984062424,2961.709124520824,M7IIIe +Antares,549.8792884370044,10001.944639646785,680.0944645545311,3493.7540570648416,M1.5Iab +Lalande 21185,8.287208290511906,-2.7308105145090122,0.43774935385563146,3402.8161906618834,M2.1V +Ross 154,9.744868120043325,-1.9897561424831252,0.22573668409489686,2760.710088775886,M3.5V +Regulus,79.24977426857156,291.6242019956963,3.2277211270197395,12493.740141303995,B7V +Bellatrix,240.1604825490851,6399.823852098992,5.650814500147861,22598.15536269529,B2III +Acrux,320.95371916990314,24996.031503914517,8.391195316883637,28004.24991812565,B0.5IV +Castor,51.644278580890195,56.21992365681511,2.346334477843539,10284.698961945825,A1V +Bellatrix,240.12473609943657,6398.402468120222,5.705004831305989,22550.69768413769,B2III +Polaris,323.34209174779676,2198.72289037108,37.55293359990409,6004.949974385475,F7Ib +Polaris,322.6559353305563,2200.8845552906755,37.522840155692826,6030.225542533901,F7Ib +Vega,24.645193901214096,35.63708969609756,2.4473367602287674,9630.116698404068,A0V +Arcturus,36.51826937834501,167.8986947873451,25.410611237912747,4240.265272852089,K1.5III +Regulus,79.3430014654726,291.897968511475,3.0685139669552144,12473.199718306252,B7V +Antares,549.6671549550567,9996.784007026225,680.0179720282729,3522.283434570003,M1.5Iab +Vega,25.05044976403771,41.84243236145427,2.3739402771698725,9625.680795323084,A0V +Barnard's Star,5.644066736935094,-2.1071580871904065,0.11794239144636819,3173.4847190903433,M4Ve +Castor,51.524741869292015,59.507990827135586,2.3006184190361902,10317.774238638101,A1V +Vega,24.892157888712624,35.69348717683239,2.380537492627866,9552.455314036846,A0V +Hadar,350.2597782764712,50002.654895780484,8.97581464551337,24989.103730471594,B1III +Betelgeuse,642.9357776183036,126002.95958230013,886.9047919744044,3456.979085219775,M2Iab +Vega,24.737344606764864,41.89763252503265,2.2693420546041287,9592.868812233257,A0V +Lalande 21185,8.26117326287019,-1.9823179200068182,0.41194940840380373,3439.577143635202,M2.1V +Polaris,322.61059291404024,2202.2714289370924,37.53181463850515,6003.310740577722,F7Ib +Polaris,322.5864706417702,2204.140987050643,37.59943203330432,6062.130413148689,F7Ib +Rigel,859.8658746857441,120000.07131490989,78.91844330403548,12088.867267715941,B8Ia +Vega,25.249302017870193,43.804966691716544,2.348973961279292,9637.870555033087,A0V +Sirius,8.872982082035527,20.848040060583756,1.741300009310768,9974.98181983591,A1V +Sirius,8.792950012705772,27.268082296015166,1.7487744731679866,9964.644559867129,A1V +Acrux,321.20334861362505,25004.06256504029,8.320476613936954,27991.65048867627,B0.5IV +Rigil Kentaurus,4.174610126906483,-0.8865713991311825,1.202079732800457,5831.440377016771,G2V +Polaris,323.0346750980348,2204.9741518094293,37.448761057267966,6061.94335486547,F7Ib +Sirius,8.355424038148003,23.40538815530837,1.675395511782884,9975.539243247444,A1V +Canopus,309.7711209452154,10499.979018032227,71.02706871184742,7307.473967313892,A9II +Capella,42.85177613657468,81.33187389246322,11.92323992211239,4957.416740309828,G8III +Barnard's Star,5.686720695342739,-4.382996087407797,0.2297698275207009,3140.2516555700486,M4Ve +Canopus,310.0723523164608,10496.598466117015,71.09120159880283,7345.8669487625775,A9II +Vega,25.473262447093777,43.66237658662158,2.4118577153974705,9579.845392970341,A0V +Spica,249.58042873493716,22002.01284198614,7.305796816633301,25449.252065646262,B1III-IV +Ross 154,9.261994125032583,-1.7574069302212032,0.2061104084369102,2784.374251562764,M3.5V +Achernar,143.78027679343387,3154.3236207651003,9.287902871852966,15030.422975953981,B6Vep +Ross 154,9.553595958712544,-3.719698732023374,0.264392402910132,2815.9211099285735,M3.5V +Capella,42.57067975593808,79.25135468067211,11.912431518691237,4983.66025502538,G8III +Spica,250.3907403268672,22001.02951453293,7.481877815189558,25416.705605945994,B1III-IV +Deneb,2599.918259573627,195998.32008414762,202.90405149865248,8553.481732116297,A2Ia +Bellatrix,239.8922067354819,6403.9860833695875,5.735235074512112,22616.156564138986,B2III +Arcturus,36.90991186856271,169.51942011897793,25.303344033945972,4290.105320704147,K1.5III +Alpha Centauri B,4.7356216586430016,5.4391034605528645,0.9091029747390225,5293.511395768489,K1V +Altair,16.69885844192648,10.045330164781657,1.5459880132642128,7550.22447695355,A7V +Canopus,310.3941896872438,10497.81775664668,70.91867852641275,7367.389499391343,A9II +Lalande 21185,8.649839719089691,4.295886834209269,0.33518679227980736,3391.275098907769,M2.1V +Hadar,350.42067052185126,49995.52898582493,8.98665029163151,24990.85112515838,B1III +Canopus,309.5515680591836,10501.834765231313,71.01144351518133,7357.767520942422,A9II +Hadar,349.98215646428145,50001.54561858535,8.992876899972615,25001.423746134496,B1III +Altair,16.515448932210074,10.994983045438705,1.6276598462375145,7519.877500379792,A7V +Castor,52.23783288286487,55.54003542527262,2.4513414857288107,10348.926244523094,A1V +Polaris,323.4573642516834,2196.226916249681,37.45283721380477,6022.601310476043,F7Ib +Lalande 21185,7.976157703677068,-2.808369984959966,0.3687356080387063,3381.2641279714753,M2.1V +Canopus,309.745118342769,10499.510031335705,71.03825079847479,7358.944699099214,A9II +Spica,249.75427247336654,22003.822501147264,7.307524781332655,25364.78612030834,B1III-IV +Polaris,322.7489734191514,2204.7744128785384,37.485240092547805,6024.551479231562,F7Ib +Alpha Centauri B,4.105591040558226,-2.182644939476517,0.7957348695211522,5219.2466306965,K1V +Lalande 21185,8.459087059993356,-0.6382579849313171,0.3413945671468163,3350.203177103998,M2.1V +Mira,417.5715531818814,8695.087924765674,369.99831282282787,2914.694050222207,M7IIIe +Rigel,859.7605775728495,119995.96883648894,78.93723792629449,12086.3345705341,B8Ia +Castor,52.00232623896764,52.94996722654462,2.4057681462625693,10329.736255295447,A1V +Betelgeuse,642.7417653348303,126003.57941062373,886.9949887668902,3483.4145245213945,M2Iab +Mira,418.19637656568926,8701.972674557059,370.0422254166163,2867.8781630265453,M7IIIe +Fomalhaut,24.50867740612027,18.07211473917685,1.8749000797134092,8631.379068954075,A3V +Polaris,323.407738492318,2198.1940301666677,37.55873111589653,5995.879155326469,F7Ib +Hadar,350.00026107700785,49999.83035343599,8.901167621981331,24972.288713403494,B1III +Antares,549.601840549149,10003.850363076659,680.0039664218791,3520.1370974335855,M1.5Iab +Bellatrix,239.87685547835358,6399.860707647494,5.842889800040897,22585.994435100132,B2III +Betelgeuse,642.5351051185136,125999.7058492993,886.9158595459037,3468.4651192281262,M2Iab +Achernar,144.47209166466283,3145.5942888328236,9.26360411552539,14987.235488734876,B6Vep +Polaris,323.329059044209,2199.635235827846,37.47946284639381,6049.7870507850075,F7Ib +Mira,417.73665480621816,8701.822617753161,370.0245119762601,2913.84044093401,M7IIIe +Polaris,323.2911371694931,2195.0672211327037,37.587127250860775,5990.137153469109,F7Ib +Lalande 21185,8.787449488767088,-4.850542159255809,0.4853641937550528,3446.293506188233,M2.1V +Deneb,2599.8398288257226,196003.52462449897,203.01133991409023,8476.333101117267,A2Ia +Polaris,323.04614166377024,2195.050035386478,37.418466240252364,6009.8189312556915,F7Ib +Vega,24.517236143400165,44.820504619636765,2.321671688117596,9606.96402235447,A0V +Alpha Centauri B,4.292306288809428,-3.312680860880921,0.8955832961310575,5275.771324524828,K1V +Sirius,8.161295441784544,28.426852478106365,1.6170664861861161,9939.136372958605,A1V +Alnilam,2000.0435647220493,53695.97175932085,32.37492240874281,27508.931727822823,B0Ia +Procyon,11.282775707529195,4.76949576438661,2.072443099360481,6487.685057371517,F5IV-V +Capella,43.353461047980645,81.76850910449821,12.063331640542366,4935.234222553348,G8III +Bellatrix,240.03574000164505,6396.904484917012,5.658809786059885,22611.214516186817,B2III +Lalande 21185,8.34956214577482,2.9000896987662736,0.44081492446226567,3439.8806178162326,M2.1V +Fomalhaut,24.70632087566867,19.65366201902202,1.893117076485662,8540.172250328555,A3V +Alnilam,2000.1010812868858,53695.577226247784,32.32051055898877,27474.76845924004,B0Ia +Ross 154,9.413783915695813,-2.891393672737218,0.26034868624042784,2804.3499435240997,M3.5V +Mira,417.5442981212012,8695.33991203142,370.05767686414055,2869.736447816347,M7IIIe +Mira,418.3989107239932,8701.315925356654,370.02181131085007,2927.0002962848403,M7IIIe +Rigil Kentaurus,4.258882694615686,0.15109681155119392,1.3039187708568605,5827.880077949218,G2V +Altair,16.5633005475685,7.297870303573438,1.6766109906548052,7519.007803232365,A7V +Altair,16.304756370563133,9.844031209497734,1.6702643739447949,7595.464571279732,A7V +Alpha Centauri B,4.416944668599744,5.437406368831601,0.7814865117291615,5309.16792907,K1V +Barnard's Star,6.00647519555047,4.339780518389593,0.14748022924353998,3087.59947084936,M4Ve +Acrux,321.1664335654021,24997.62427883933,8.369295055678041,28042.452109462603,B0.5IV +Achernar,144.0426282760542,3149.5847166204003,9.296361656350818,15042.352316612354,B6Vep +Hadar,349.64750946004904,50001.30848857186,8.935823479319179,24970.52644639602,B1III +Arcturus,37.06384846154293,170.0454143979509,25.365565320886823,4287.666024064305,K1.5III +Barnard's Star,6.260851555777831,4.2615291791448895,0.13747389922746123,3145.5643427298896,M4Ve +Fomalhaut,25.11565259218312,15.593328911780318,1.8895643475157593,8627.32592216615,A3V +Alnilam,1999.772368135856,53703.811722428116,32.33022315461439,27521.38144228824,B0Ia +Wolf 359,7.582497882510385,-1.5632476218580127,0.08468250239819325,2779.714321931838,M6V +Barnard's Star,6.450229446881884,-2.18689689184772,0.1975531962534991,3129.461198007409,M4Ve +Rigel,860.1545306223537,120004.13495106822,78.8606542863585,12054.800080636292,B8Ia +Vega,24.905127460760955,43.18165538748461,2.4431624121084563,9643.409478794498,A0V +Alnilam,1999.6818716533849,53700.100064197555,32.38561166851854,27531.156640075733,B0Ia +Procyon,10.901203554984239,10.449552952648414,1.964464506692388,6509.1975557905225,F5IV-V +Fomalhaut,24.843117080136953,21.436023244445632,1.8758857975904695,8630.935241492118,A3V +Ross 154,9.395163970336052,-2.197465144382473,0.21193018974631786,2842.2669877441795,M3.5V +Antares,550.1496804937102,10004.657720081826,679.9174283014403,3454.7264921717583,M1.5Iab +Hadar,349.77510792216157,50004.78063934145,9.081576314653484,25041.212161908214,B1III +Altair,16.37496066970492,12.09829147440001,1.7019959923743562,7534.106668785498,A7V +Acrux,320.7411078477193,25004.514480134185,8.477723800201261,28029.389208052286,B0.5IV +Barnard's Star,5.617672919304961,-1.2413399237183214,0.1356375379905401,3178.000040613115,M4Ve +Spica,250.15638901295986,21995.941108441966,7.475743207321835,25414.30599441595,B1III-IV +Aldebaran,64.61409509358059,518.6712000572877,44.100220204171734,3958.8680826103705,K5III +Canopus,310.2130102878391,10504.654048072583,71.07894930007686,7379.148590519233,A9II +Ross 154,9.620779679219527,4.204083163586541,0.10109845734577672,2832.573702541216,M3.5V +Fomalhaut,24.88012046688512,21.01584823433142,1.8795552591453484,8583.60227860466,A3V +Altair,16.93853726095821,13.80452322428447,1.570032145800845,7573.295668388958,A7V +Barnard's Star,5.702119231490174,3.219268580719352,0.2660142176131456,3098.7266249750223,M4Ve +Antares,550.15747463314,10004.598266981333,680.0689642449811,3512.261757514086,M1.5Iab +Altair,16.738703832546104,12.635282043125049,1.60414075684068,7547.966393001522,A7V +Canopus,310.48390031214797,10504.519240373209,71.03402804245088,7325.974670766734,A9II +Polaris,322.66831382848295,2196.0992646991313,37.4552240516604,6060.406407380209,F7Ib +Aldebaran,65.47022713417984,515.9542990912557,44.12764592405856,3893.0143990576466,K5III +Spica,250.08854976539027,22001.578767457122,7.414209442660478,25366.445174691453,B1III-IV +Arcturus,36.201805732854424,174.7332915546677,25.441499743098746,4248.408030847584,K1.5III +Aldebaran,65.40799412250136,519.5755247353721,44.15412909069042,3918.9688260663343,K5III +Rigil Kentaurus,3.878440741323109,6.022386273451476,1.3197646992703684,5820.648373206649,G2V +Altair,17.19019344606041,10.378557473919681,1.6290226128685181,7544.3574372605435,A7V +Capella,42.601051224886014,80.55609974454067,12.083935912969388,4917.89083875077,G8III +Hadar,350.0482509324234,50003.86564599455,8.932386986597969,24972.701938014114,B1III +Canopus,309.59630094036703,10504.380309759488,70.9827132261566,7351.883170833618,A9II +Canopus,310.4362927684538,10499.900137740964,71.01185563957658,7347.0506407299135,A9II +Deneb,2600.1549731280975,196000.6019332607,203.0741494173092,8542.391046665773,A2Ia +Regulus,79.25123296644107,284.6113183408361,3.0640541856428465,12509.174094134512,B7V +Altair,16.652395810820618,13.76552132295723,1.6958658200385244,7524.274006888235,A7V +Lalande 21185,8.080258523322932,1.8038499721446757,0.3969354609839206,3411.065504109538,M2.1V +Antares,549.7495418978335,10003.242024216936,679.9228252871035,3475.843044583647,M1.5Iab +Procyon,11.652618800686213,10.356550330420028,2.0083135703070116,6506.392447223969,F5IV-V +Rigil Kentaurus,4.453129603173108,5.091762720240075,1.2355169652704114,5747.726483412773,G2V +Bellatrix,240.4175407764292,6401.369851611912,5.825240279295632,22560.290030046803,B2III +Capella,42.86175604553599,82.12800808127493,12.001168562413225,4977.929659601225,G8III +Bellatrix,239.83034161607173,6403.880675893539,5.653185314768504,22577.579583431743,B2III +Arcturus,36.55163108724785,167.96548996936522,25.37445361647329,4276.636208120183,K1.5III +Arcturus,36.24521475154246,171.06523787104854,25.472991357926276,4302.672551181282,K1.5III +Fomalhaut,24.987398402267782,16.74259464502824,1.8140570759654286,8589.47114397441,A3V +Procyon,11.27128784093913,8.557845789578323,2.124490517134602,6562.591621685544,F5IV-V +Mira,418.1733391023294,8695.589846031997,369.92632017029786,2946.8793696961584,M7IIIe +Barnard's Star,6.145792735966175,-0.9684916387749309,0.17181750237319438,3103.3844422534357,M4Ve +Ross 154,9.694723071221121,0.23225073430305138,0.203383332137128,2787.4460236246564,M3.5V +Spica,249.96142719523124,22000.294090577478,7.36264583680692,25352.103798765987,B1III-IV +Betelgeuse,642.2829746395311,125998.07097370525,887.0699500398044,3530.1366694495227,M2Iab +Castor,51.92513481887208,57.74910943563771,2.349011969908936,10275.188470871104,A1V +Bellatrix,240.11588978221366,6395.26517269466,5.83374013548201,22593.821568670417,B2III +Mira,418.027891124594,8704.120455744414,370.0255654712494,2891.0751547963814,M7IIIe +Alpha Centauri B,4.048885138846404,4.695039829686282,0.9492397335394827,5213.857078948171,K1V +Bellatrix,240.49816951913863,6397.660532171655,5.730954914739205,22639.051133471075,B2III +Ross 154,9.323389346236949,4.995794616096258,0.18334509752705908,2775.2989538036636,M3.5V +Betelgeuse,642.9649766370246,125999.82301556024,887.0979364514885,3504.3350172796913,M2Iab +Ross 154,10.01828345662197,-4.25830044406204,0.13628988553632382,2823.523215533399,M3.5V +Rigel,860.3803983161446,120004.72283034294,78.82018398856654,12100.438814515885,B8Ia +Betelgeuse,642.3397970219621,125999.46554318475,887.081956248057,3541.5394048862668,M2Iab +Rigel,860.203922875534,119996.4155145593,78.87669661220816,12055.656446810095,B8Ia +Regulus,78.53223893334071,290.753427669009,3.136862623424212,12443.071441715329,B7V +Ross 154,10.175313678033959,2.325660828881204,0.21689024523526124,2777.231536042371,M3.5V +Procyon,11.462361693741704,9.344709778320805,1.9525975942032046,6491.439308386985,F5IV-V +Hadar,349.67138194692,49995.77634359074,9.055189649808424,24996.604714648234,B1III +Altair,16.427968131235406,7.07921158123882,1.6177446982874082,7507.670927457083,A7V +Mira,417.7473616627305,8699.858562700023,370.023915277761,2893.530511176531,M7IIIe +Sirius,8.441644923384983,28.842977654972252,1.7321340809915053,9904.135843415539,A1V +Fomalhaut,25.302837879907862,16.57558732704546,1.7777299084901526,8593.340445848311,A3V +Wolf 359,8.201477766291974,-2.54824077781722,0.1864536412152862,2798.074278401116,M6V +Achernar,144.3182802277197,3146.480170764414,9.27999260361189,14958.360315310432,B6Vep +Capella,42.66974559185838,78.78259516215284,12.086628584613813,4916.61652489648,G8III +Vega,24.75073833045015,38.18906551332613,2.444695198270377,9565.248166881567,A0V +Deneb,2599.9603466154435,196004.3424013923,202.91890429889867,8570.918996413824,A2Ia +Ross 154,9.958709975740943,-3.8029930871625424,0.25963073001395726,2831.330101601942,M3.5V +Betelgeuse,642.6428013612522,126000.70393546818,887.038310180379,3465.6798574641743,M2Iab +Altair,16.79957336533521,11.204367428023975,1.551883163732196,7584.109813177932,A7V +Arcturus,37.061491278377275,171.08994172322014,25.388762785497054,4317.534265905345,K1.5III +Ross 154,9.338424894825856,-3.1054206734561505,0.2037275811208312,2791.879820379679,M3.5V +Achernar,144.2578184530899,3147.1222148999486,9.219363135213808,15004.851529514077,B6Vep +Ross 154,9.6890022970437,0.6618484621567702,0.1717221080301523,2776.494430453399,M3.5V +Hadar,350.39958330018277,50002.19425747596,8.971351243480997,24982.90241909227,B1III +Hadar,350.4252257682298,49996.40808398428,8.909946496696577,25040.24037543401,B1III +Ross 154,9.343641962410091,1.1161883918936018,0.1697888884849568,2842.8916555993164,M3.5V +Polaris,322.8440108934349,2199.089387691352,37.46689922695562,6046.631277560694,F7Ib +Betelgeuse,642.5944222595335,126001.85035674136,886.9907022445946,3477.294014444043,M2Iab +Castor,52.16408562397163,52.94281733759341,2.43893958684956,10266.745885879896,A1V +Polaris,323.0169808270724,2195.186971182001,37.59925970521094,6050.625462057052,F7Ib +Achernar,144.19189867653805,3153.3756737430845,9.190603416046434,15020.470409544698,B6Vep +Alnilam,2000.4282349640357,53700.31332169274,32.46273502957565,27544.092507267513,B0Ia +Capella,43.20824019631963,74.82324607778462,11.936028986577934,4958.827123576126,G8III +Mira,417.66357675406744,8700.068256603763,369.93195867813347,2890.9614796355236,M7IIIe +Canopus,310.4345692965066,10500.98757952869,71.08703647661739,7377.625841273283,A9II +Achernar,143.62996068798947,3154.434596715594,9.195174942470567,14969.687240263747,B6Vep +Castor,51.71719885193044,59.27555252752218,2.3098516603102723,10307.441978064015,A1V +Spica,249.81724035555638,22002.81493518628,7.376620311387307,25446.0823523032,B1III-IV +Hadar,349.9788637308732,50001.5153382736,9.083821056935266,24994.194604798136,B1III +Acrux,320.7317413396748,25000.378673015985,8.376762587797739,28036.07557496071,B0.5IV +Sirius,8.217525695491645,21.290729913681044,1.7889816994864702,9962.816458916797,A1V +Rigil Kentaurus,4.367149037495067,-2.702274636517478,1.1278798822075493,5780.201471720773,G2V +Betelgeuse,642.7547888998598,126004.90781506641,887.0573491617093,3476.8994046145294,M2Iab +Castor,51.69175345874459,57.72693991417189,2.4478353989623547,10281.56309566833,A1V +Mira,418.10374930422336,8698.967657743355,370.06505605278187,2874.881539218159,M7IIIe +Sirius,8.514812239311194,27.29089566573881,1.652647638799747,9969.816067195901,A1V +Vega,24.869127463113156,43.204179984989,2.2835895991099027,9607.604869049528,A0V +Achernar,143.62812373331911,3147.519402614194,9.191147525200837,15023.398629349866,B6Vep +Altair,16.865327747799885,14.955319493691704,1.6548262856677256,7575.545065897934,A7V +Polaris,322.9494783167867,2202.0033277855146,37.48292311916111,5984.444343601622,F7Ib +Rigil Kentaurus,4.117935511045086,2.757813672726318,1.2937921481463304,5788.769114750748,G2V +Altair,16.28254828170139,12.877132083863422,1.644210045470566,7570.265230089273,A7V +Barnard's Star,6.036902451485217,1.224626677565773,0.21198367409015023,3142.0110438218135,M4Ve +Polaris,322.96013716898085,2203.512057055408,37.57026948675216,6029.833651811472,F7Ib +Vega,25.224131593103422,45.0166194805538,2.388746056315712,9587.638032944775,A0V +Barnard's Star,6.213758808682438,-0.12394387343218578,0.10145458604760314,3165.864693253415,M4Ve +Mira,418.4812503161386,8698.01996291219,370.0509724752987,2942.3260270232745,M7IIIe +Arcturus,36.200295183387695,166.1544445734457,25.306280133253583,4268.512939873438,K1.5III +Castor,51.70958451784467,56.46782683458471,2.347139645721716,10316.38512335867,A1V +Aldebaran,65.02609193401285,517.3793363363512,44.18758078494204,3957.570031856471,K5III +Vega,24.563347691310778,44.60627511934049,2.401900913735243,9643.406190738913,A0V +Rigel,859.5517800045906,120002.14531240135,78.89279917967544,12085.345084429657,B8Ia +Barnard's Star,6.35870919542279,-1.2840939008158352,0.10759501316461217,3153.8260425106946,M4Ve +Deneb,2599.585898833314,195996.36536262257,202.9196724424709,8488.600716520197,A2Ia +Betelgeuse,642.7994618404347,126003.92358533299,886.9401128838214,3539.286982736836,M2Iab +Altair,16.586513640803055,10.000669193136112,1.6084090606106165,7585.266686686432,A7V +Spica,250.47669935243394,21996.342337509686,7.344682975230628,25409.571306663907,B1III-IV +Ross 154,9.420865497366739,-2.1016283109970986,0.2655907792418205,2791.6051488885696,M3.5V +Regulus,79.22183035219693,284.01315760447636,3.1487905306547903,12462.658099346727,B7V +Fomalhaut,24.59512350793306,15.016026009991702,1.8112492365103927,8548.342664548874,A3V +Alnilam,2000.2993114511182,53701.62960708246,32.36720893475078,27516.762234862374,B0Ia +Deneb,2600.041523441383,196002.04752224215,203.05889922405453,8526.202509288612,A2Ia +Polaris,323.17960144669274,2201.6145592702355,37.507793416339844,6010.871921511619,F7Ib +Achernar,144.28801530852505,3147.7105681972444,9.168823431212418,15010.583530211014,B6Vep +Sirius,8.294591987099164,21.835288048407183,1.711812404046795,9985.973819046825,A1V +Rigel,860.1589940381065,119998.58199670307,78.9076767992332,12134.595219353163,B8Ia +Fomalhaut,25.023792942363187,18.722897335306822,1.7973320531792463,8610.627278334628,A3V +Regulus,78.7038439341687,289.64944522566566,3.2179018430622066,12411.895586802231,B7V +Sirius,8.165437979968027,29.994667372009317,1.6562709828231825,9980.82023330545,A1V +Barnard's Star,6.180499325090577,0.552561765814839,0.25431549912816764,3177.86161038409,M4Ve +Mira,417.6039056772467,8702.813860527409,370.03680605242215,2939.513730202739,M7IIIe +Rigil Kentaurus,4.268672294663512,6.221478664884197,1.1443512574950072,5795.595953531607,G2V +Antares,549.5110445555379,9997.044095222524,680.0163575557061,3494.0726115607513,M1.5Iab +Rigil Kentaurus,4.763026573907034,0.2644097525168283,1.1665260036299694,5811.4839403268425,G2V +Sirius,8.450983252622061,22.57276367080033,1.6988894628307967,9956.88228122458,A1V +Arcturus,36.90817729219896,174.5022470890357,25.434310203099425,4250.541509306832,K1.5III +Antares,550.3257829728522,10000.229128287727,680.0786257942112,3514.785476299065,M1.5Iab +Procyon,11.856853389499038,4.084635008945639,1.9804040224558817,6490.62994930066,F5IV-V +Sirius,8.696116019165396,26.458827123826993,1.7755826045361067,9989.222846679533,A1V +Alnilam,1999.771262670854,53699.79694685788,32.46758585918102,27466.691841661253,B0Ia +Mira,417.9030258925673,8698.681150673214,370.0603742887138,2896.357311201763,M7IIIe +Alnilam,1999.847160965611,53701.72775373246,32.30838386332203,27472.86826246571,B0Ia +Altair,16.84594097685513,8.305906773624343,1.7279546128272603,7596.955799920304,A7V +Altair,16.259098046844812,13.846836314385401,1.6249264589761316,7503.198695157891,A7V +Ross 154,9.54230139060007,2.1886629377110567,0.16376265777572935,2758.9153166919705,M3.5V +Rigil Kentaurus,4.47272804209522,4.099368934735667,1.1900459430960029,5754.412169044086,G2V +Antares,549.6919169775477,9996.300622803004,679.9247293617029,3477.3216641912486,M1.5Iab +Hadar,350.25905864555745,50001.20894607176,9.09698356608045,24974.389499648816,B1III +Antares,549.5976615005139,10004.217631330948,679.9713928011518,3464.6861674704955,M1.5Iab +Arcturus,36.631716763839854,165.74366585402294,25.41254994849308,4256.012925654343,K1.5III +Mira,418.2024794852146,8695.237868855855,370.050055956344,2949.59843529128,M7IIIe +Vega,25.30909291443033,42.20864976295121,2.4550101820189787,9620.982140996646,A0V +Castor,52.05461972836282,50.973167617405885,2.457977646129815,10272.829180232311,A1V +Vega,24.975018144839115,36.15927611791007,2.305460335409602,9600.06813602514,A0V +Regulus,79.03647559318077,283.8012330687599,3.0518390779373137,12425.653569355301,B7V +Castor,52.131041124741245,52.029091298701935,2.355537695191454,10309.551524443877,A1V +Procyon,11.71537044507152,4.204794097541385,2.1183555303474164,6498.60808011053,F5IV-V +Barnard's Star,6.065584934966928,-2.2458142045094536,0.14577876449270155,3166.076888493488,M4Ve +Achernar,144.30522567719555,3150.6838617989415,9.11989536073935,15020.46748379989,B6Vep +Bellatrix,240.355324424342,6402.769654543594,5.664436824334797,22635.110314017613,B2III +Canopus,310.41086000460473,10504.27406349011,71.08017097291058,7371.569156844817,A9II +Alnilam,2000.019834141603,53700.34763389309,32.44125257800921,27532.707139201575,B0Ia +Polaris,323.46676302972094,2201.568275855691,37.453193958262325,5966.955999982434,F7Ib +Ross 154,9.394693710190698,4.825136716868186,0.10027334445352819,2810.4327322043414,M3.5V +Achernar,144.12082466595672,3146.6213001471715,9.198703848496667,15019.011484330236,B6Vep +Achernar,143.94387870463663,3150.9412614052767,9.123318610805486,14980.02388117685,B6Vep +Mira,417.9005443831684,8702.202833665075,369.98871645048825,2957.7497631264423,M7IIIe +Betelgeuse,642.4543021202028,125995.41518186204,886.9390482980857,3514.540516537663,M2Iab +Bellatrix,240.0939753540742,6395.94572852049,5.830344564907593,22584.641409450516,B2III +Fomalhaut,25.057041949883782,17.721002225949256,1.8805468809345394,8583.876872899857,A3V +Achernar,144.37545652663016,3153.991524139571,9.194132132397257,15023.277967810523,B6Vep +Sirius,8.125496220548296,29.618483550540468,1.8024111349156222,9930.55013099281,A1V +Altair,17.02245126935604,8.864437316819597,1.6001508112184524,7574.193194719991,A7V +Wolf 359,7.281173811634308,4.649196811314523,0.18195227366180997,2750.18316322717,M6V +Sirius,8.131880808724219,23.77685282217612,1.7400088801299618,9937.970585826915,A1V +Castor,52.457966963372506,51.98803266275879,2.3660644430248006,10289.050138459937,A1V +Procyon,11.717346818680609,7.10025729213628,1.9959549703376542,6522.2839614907125,F5IV-V +Aldebaran,65.18136662184412,514.8148240807491,44.26826995770899,3948.2706417904647,K5III +Spica,249.68138707151607,21998.184803287884,7.43391918021423,25354.760298288707,B1III-IV +Antares,549.9795888740322,10001.091527688566,679.9839995249637,3489.316857387088,M1.5Iab +Sirius,8.417698116123512,29.61806382751717,1.6747498195930721,9890.83084583004,A1V +Wolf 359,7.3425435958137015,3.936431623279447,0.16797910146953993,2775.3254504305974,M6V +Canopus,309.87474133180893,10501.168802287524,71.05254781057803,7315.094835217025,A9II +Altair,16.23721181862846,12.344819495591512,1.660459279450591,7563.900534441985,A7V +Spica,249.85189898596667,21995.883722726554,7.315706064581375,25437.27143446986,B1III-IV +Altair,16.48246411572928,9.747816453214007,1.5898613302591984,7580.672464444846,A7V +Sirius,8.99668874623692,23.052795889147824,1.7613141304444038,9938.687704572661,A1V +Deneb,2600.396323397126,196001.2712595682,202.9110234905431,8502.129769951209,A2Ia +Canopus,309.6236031075072,10504.088259861765,70.96284026608309,7369.328055710798,A9II +Canopus,310.48243578628234,10497.8382083774,71.05605490742369,7322.452016967692,A9II +Alnilam,2000.087785793082,53696.046871616774,32.35610548158136,27535.46638482365,B0Ia +Ross 154,9.73233499796961,-0.13663950403117603,0.12277645023766373,2818.8336041134403,M3.5V +Castor,51.65789051774216,53.5483598096434,2.3737855898364355,10280.627339336314,A1V +Altair,16.693808179094987,5.862808829513872,1.6777831084621908,7515.8746213954055,A7V +Sirius,8.609892014115287,21.8857341790593,1.6236436341523155,9942.70660868217,A1V +Ross 154,9.665675716938939,-0.5758550149259771,0.13181005608214225,2783.696263983179,M3.5V +Deneb,2599.8786371463316,196000.73776624582,203.05299059081196,8502.720545412836,A2Ia +Achernar,144.12897129708412,3151.110905749236,9.144653143354631,14985.780636856558,B6Vep +Fomalhaut,24.506784896336363,16.135837070261726,1.7578164707678812,8590.7475373563,A3V +Alpha Centauri B,3.9584080451775816,-3.297187675128017,0.9212616532498983,5251.736584055901,K1V +Altair,16.815484644936603,11.676240801306767,1.5904287598953877,7586.739011976568,A7V +Acrux,321.3696466801406,24996.39015491464,8.431677577754863,28034.701060407544,B0.5IV +Fomalhaut,24.674402107140626,13.7039415589256,1.8328955986084499,8579.788756432894,A3V +Capella,42.93959400923444,82.8004754713212,12.011054177197959,4958.711607051215,G8III +Fomalhaut,24.579087741348822,13.958971109418881,1.7501833502327868,8613.571139982218,A3V +Regulus,79.26907248189737,288.3480381307577,3.203960431680202,12424.918660191894,B7V +Altair,16.384894337466907,8.298347815555948,1.7139575471199628,7507.620707220983,A7V +Betelgeuse,642.0286903282115,126002.66983139454,887.0641843518598,3545.1863123922676,M2Iab +Bellatrix,239.8539329933873,6397.123276113184,5.6646857858763555,22643.410634331743,B2III +Capella,43.168855975372594,78.99888567363215,11.914870285381053,4978.067407478519,G8III +Wolf 359,8.045698163666097,-4.932927078405668,0.14161913177165814,2758.7365179403314,M6V +Canopus,309.91561703948685,10499.655074189855,71.05051087782758,7352.150184817104,A9II +Alnilam,2000.138809353711,53697.570906096975,32.40561791900349,27518.18088037686,B0Ia +Mira,418.32320166950245,8701.197585745507,369.93011903077894,2891.915304894586,M7IIIe +Barnard's Star,6.1037262692147225,3.443943758367646,0.2339368014597999,3142.564884230803,M4Ve +Deneb,2600.2955537000526,195995.58873204212,202.95055105842096,8541.01760007444,A2Ia +Alnilam,1999.8175025097764,53704.09858897733,32.402136824226595,27510.32322365626,B0Ia +Spica,249.69579540727176,22004.5128505599,7.470181342699604,25379.48379071817,B1III-IV +Hadar,349.9815410499482,49995.77038141611,9.076066040945259,24982.96274919662,B1III +Castor,52.32699048051961,53.420925001184415,2.437078585961774,10297.115157355915,A1V +Ross 154,9.503661197267439,3.220604016862652,0.2288843648308101,2822.1954308408585,M3.5V +Mira,418.14707601742595,8703.371448664344,369.9868826183402,2867.748412919107,M7IIIe +Alnilam,1999.7698305372085,53702.0634950232,32.45686910732605,27547.044790247517,B0Ia +Betelgeuse,642.2428428824071,126002.01938722763,887.0221546973036,3529.268836149946,M2Iab +Barnard's Star,6.178068736680354,-3.2113888363806904,0.21951803717127363,3090.3390397328903,M4Ve +Lalande 21185,8.172252612662689,-1.028153800053883,0.3384603857531662,3375.3820084864246,M2.1V +Wolf 359,7.844657382582614,4.371104753943822,0.18670348951585247,2753.9277386177027,M6V +Altair,16.720463318238917,13.65940052736991,1.5430356061501627,7550.999958128935,A7V +Betelgeuse,642.1508982777278,125999.93767974032,887.0378795375067,3477.7581326392396,M2Iab +Spica,250.01953470530412,22000.26467615668,7.475964613182765,25379.910058484376,B1III-IV +Ross 154,9.25339808628094,0.036706867156804324,0.17652201100689272,2842.689311652104,M3.5V +Capella,42.58145468080607,74.5898698350332,12.032243019462545,4931.267519994569,G8III +Hadar,349.6886337761157,49995.749619117036,8.910999597918133,24967.945311684325,B1III +Alnilam,2000.3439769385386,53698.49121410144,32.46869841130035,27471.89447939077,B0Ia +Ross 154,9.540019221183611,-3.391033640909636,0.1861570500555818,2802.981438562782,M3.5V +Lalande 21185,8.728312637512095,3.9489165851514327,0.4112335190191624,3424.255245200203,M2.1V +Arcturus,36.88591656890159,174.47262087336912,25.326254958607212,4281.808090819703,K1.5III +Castor,51.57416859712489,53.77756011373539,2.387367884736203,10317.4243706405,A1V +Castor,52.008251054307145,57.401302147549586,2.4089978300984596,10314.745550007337,A1V +Rigil Kentaurus,4.426806628560027,-1.4618778575732707,1.2744721164642068,5779.562644917379,G2V +Mira,417.540276775724,8704.173393016803,369.92211980166724,2918.022650902731,M7IIIe +Altair,16.775942941441293,10.10010584380826,1.5444472033269074,7558.441651327932,A7V +Polaris,322.62947492209986,2197.7574673579934,37.505780269671966,5995.9036513716665,F7Ib +Castor,51.630997393351066,51.875004243619685,2.342184329683412,10274.638211687447,A1V +Ross 154,10.043819467396546,-4.321045206678933,0.197416923321287,2782.787399839951,M3.5V +Castor,52.201794739444864,50.44141160659301,2.4282526515634872,10341.330728581563,A1V +Alnilam,1999.8175408088105,53695.258770385415,32.47725481222176,27488.06800739985,B0Ia +Canopus,310.44468131175495,10496.030199977424,70.99730155189135,7354.889587745839,A9II +Sirius,8.786491000164645,21.657048252464076,1.7044749078699848,9933.824285410792,A1V +Canopus,310.4335412085039,10504.63622854095,70.99838507231725,7309.979472382426,A9II +Vega,25.424516219453206,39.769433629724084,2.4182676711303106,9611.083008168196,A0V +Sirius,8.52608695906616,23.937961722565305,1.723719605227032,9907.795585729282,A1V +Polaris,322.9599285464444,2204.3731029077067,37.54252649440859,6026.416076232229,F7Ib +Capella,42.88148825879285,81.66897522329074,11.979603009407757,4897.291754840095,G8III +Antares,550.2150054467941,10001.124556352737,680.0174917738268,3483.3372105663907,M1.5Iab +Regulus,79.18589591612577,291.23101596438744,3.1228520908675015,12504.48269494128,B7V +Alpha Centauri B,4.3968645150592645,3.150212948153516,0.7855091128785929,5260.158510468461,K1V +Canopus,309.6647970437859,10503.548509647142,71.00155455588713,7360.543323526215,A9II +Altair,16.68375873060525,7.394938938729514,1.711416854356158,7546.0394407030835,A7V +Rigil Kentaurus,4.105156452641697,5.414415558348379,1.2857885445709951,5799.379142495786,G2V +Alnilam,2000.3702369025798,53695.108957947356,32.37604999388101,27534.090269013206,B0Ia +Canopus,309.92408716748804,10499.8550745283,70.95195914765361,7360.486229849605,A9II +Canopus,310.1097294620209,10502.148872748416,71.0322091487245,7370.643334257277,A9II +Hadar,349.625907898617,49995.52830393315,9.081673236636975,24998.83324237804,B1III +Alnilam,2000.4460408974742,53698.854158422546,32.39278486850108,27511.59449014505,B0Ia +Deneb,2599.6979557308987,195995.0992175819,203.01060296352694,8527.764168916607,A2Ia +Altair,16.474888428566707,7.834658999592028,1.6389668348850974,7545.921513832263,A7V +Acrux,321.457318249747,24999.57439378584,8.482459146978215,27967.66144582767,B0.5IV +Procyon,11.519994192475885,9.101577122041768,2.009341157544421,6484.687330914862,F5IV-V +Spica,249.73242975661938,21997.98059477522,7.464590495208748,25401.660996875093,B1III-IV +Rigil Kentaurus,3.9157177266609406,2.729758830183819,1.3145897006685279,5822.170978801114,G2V +Capella,42.40535655093325,73.79446502380395,12.048231077918146,4964.061857054726,G8III +Antares,549.9015809654044,10000.569394629441,680.0400647264704,3513.3180132938974,M1.5Iab +Rigil Kentaurus,4.267358434464539,3.343284346674393,1.2319002782029658,5786.671616375054,G2V +Bellatrix,239.93656975922684,6397.114822384684,5.811521539250009,22556.547471136837,B2III +Capella,42.94182808506701,80.73590843810881,12.067925196745186,4929.859437580991,G8III +Acrux,320.5286601685961,25004.963250979177,8.304098489208993,28028.48279908378,B0.5IV +Barnard's Star,6.378422052335232,1.5172684861294066,0.12501017932776898,3100.021583618778,M4Ve +Rigel,859.7391892037019,120001.17653277425,78.88565018109219,12115.329269984008,B8Ia +Altair,16.964525968063487,14.701676306464835,1.6274152182163095,7518.945065616684,A7V +Rigel,860.2515676737628,119995.55867207545,78.93150936087208,12072.474772341315,B8Ia +Acrux,320.5295666259734,25002.57473766397,8.394867761464171,27960.76695110712,B0.5IV +Regulus,78.7031566878579,292.2930937776625,3.148963428439032,12461.997325664423,B7V +Regulus,79.2976565838651,290.70024983213216,3.041486049514461,12474.700386432494,B7V +Canopus,309.7469731020621,10499.697004945498,70.93042410447167,7349.441517991896,A9II +Bellatrix,239.62482417096467,6403.603918761972,5.839515611968588,22636.26995306118,B2III +Regulus,79.08867706312137,291.10560374811564,3.130152042623166,12497.892594780458,B7V +Altair,17.142746638457286,6.884995985017756,1.5788215885170005,7513.945194498599,A7V +Capella,43.32463110238659,81.9754180341863,12.071053341137814,4949.377973773141,G8III +Rigel,860.1419899425256,119995.89640814654,78.8025657673106,12110.136426804222,B8Ia +Hadar,349.97949588756546,50003.56016712869,9.08813244926153,25014.000325342575,B1III +Ross 154,9.404553220913916,-3.867373936810584,0.14587737603167075,2796.7281003474714,M3.5V +Fomalhaut,25.35547709191822,13.00282551613866,1.8930566958371888,8618.813384063416,A3V +Arcturus,36.982286233375945,173.085282002199,25.380949927424062,4289.865959355165,K1.5III +Ross 154,9.423694155811315,-4.657914346992305,0.1859237379345144,2795.8992910559946,M3.5V +Arcturus,37.001402789128804,172.842832715623,25.315570628253187,4249.884918928173,K1.5III +Fomalhaut,24.878075095256886,17.6590827182039,1.9098870191442743,8591.96683545127,A3V +Barnard's Star,5.628109879472458,-0.6037036495492716,0.1625247037040758,3183.0860188875836,M4Ve +Altair,17.15840501478534,7.948793884207701,1.6856851253944578,7547.195801781259,A7V +Regulus,78.57997164692497,289.3498810069176,3.1299823397283855,12432.518477392956,B7V +Canopus,309.79894282933685,10497.145990895167,71.09424888312614,7345.4502213525075,A9II +Capella,42.81063050433714,81.28907430396127,12.022748942603286,4957.0885962511065,G8III +Aldebaran,65.06561799990496,515.9161452954957,44.10146640607368,3958.159737052663,K5III +Achernar,143.9947292602552,3148.5608771151096,9.234108291017753,15015.002146792054,B6Vep +Arcturus,36.83263226386889,167.9528635926058,25.46378069412647,4327.684401064919,K1.5III +Bellatrix,239.83337339555473,6400.46860322045,5.793992106621911,22554.815269819006,B2III +Spica,249.6676091992805,21999.50880771162,7.397536383443229,25405.394486073717,B1III-IV +Barnard's Star,5.702693106793509,-4.366184134543582,0.12275631468671855,3177.508223083716,M4Ve +Canopus,309.70210821887525,10503.31030234475,70.92716241622037,7361.733098949267,A9II +Betelgeuse,642.6498975327032,126001.05324147755,886.9727580308341,3516.278490702142,M2Iab +Sirius,8.322247873554318,28.370754902069887,1.7712946273664132,9899.251280237186,A1V +Deneb,2599.9535579119542,195997.37731195986,203.08798443709676,8520.928914962555,A2Ia +Spica,249.5219180074977,22004.27059391161,7.410378264678557,25360.450834055307,B1III-IV +Alpha Centauri B,4.734661764734593,0.7214286156354033,0.9003572587976699,5262.821537849697,K1V +Achernar,144.44176753543127,3147.427280159967,9.248736985779704,15043.701389655529,B6Vep +Hadar,349.5488295994064,49995.84780935522,8.97618201590831,24978.367925100425,B1III +Betelgeuse,642.9972303663835,126001.97593175896,886.9746222002453,3524.018096616606,M2Iab +Fomalhaut,25.387269675813,15.87277895997164,1.8656431002512202,8601.573936205677,A3V +Antares,550.3668196570269,9996.691025435097,680.0861595410729,3489.6432831898605,M1.5Iab +Rigil Kentaurus,4.475035634017177,0.2757210086922075,1.226504787549934,5834.976699377089,G2V +Aldebaran,65.00813676993866,521.7244786179083,44.22527027389398,3944.8040882551327,K5III +Wolf 359,8.049625037667944,-4.8115986940459345,0.1239026747447862,2766.688801248895,M6V +Wolf 359,8.193452392455221,-2.3500029874210884,0.1414320226576321,2762.8062819494235,M6V +Polaris,322.9314640081101,2202.4539536291118,37.56112835239332,6062.42405904522,F7Ib +Betelgeuse,642.0106189270315,125996.39982220321,887.0351881770529,3469.2993815801715,M2Iab +Aldebaran,64.69365732542286,522.1631626285894,44.160898686119936,3940.9822432178307,K5III +Bellatrix,239.59086023679924,6399.16773375399,5.766317882271089,22587.204959100887,B2III +Rigil Kentaurus,4.379249967683409,2.0406154870872886,1.1600268689818491,5793.002083572658,G2V +Wolf 359,7.408588147182553,1.2352036190162132,0.15785804573998818,2845.898752704132,M6V +Achernar,143.7260830353571,3151.0686597665713,9.239357999516285,14989.273880147064,B6Vep +Alnilam,2000.4345492686696,53698.69091540687,32.3576935985781,27525.63189793421,B0Ia +Betelgeuse,642.8476080979914,126002.76484556652,886.9976506963349,3522.5900483929627,M2Iab +Castor,52.296788171138225,53.895187185673116,2.3101292175919568,10277.085744461123,A1V +Rigil Kentaurus,4.384779238681924,-1.3006426880404602,1.189019218423591,5824.4980843607,G2V +Procyon,11.337639813967616,6.549661020142606,2.1452893909003112,6505.351830089427,F5IV-V +Spica,250.08391615971536,21995.51832953527,7.398323409818835,25369.11067017667,B1III-IV +Vega,24.905854171943336,43.235486536521336,2.3415050019576458,9590.627166737077,A0V +Ross 154,9.389919670573615,-4.904825044713256,0.15186594861175973,2839.2519190707767,M3.5V +Barnard's Star,5.6718348599570705,4.492661755525925,0.179828146431155,3138.564205419862,M4Ve +Ross 154,9.386066440277858,3.7433482179444604,0.19743579236798048,2795.0690967234927,M3.5V +Altair,17.11637322103638,14.390175657466854,1.5978895123290324,7547.36891136891,A7V +Achernar,143.98542586931663,3149.1255196486113,9.2851196428525,15033.350023545858,B6Vep +Alpha Centauri B,4.808567597775965,3.037716850015165,0.9207197947390062,5264.445096291327,K1V +Bellatrix,239.77263433505865,6404.8043623040785,5.7502530574731,22611.937403764936,B2III +Canopus,309.9536271445739,10500.111323871244,71.02716196864583,7319.533855493223,A9II +Castor,52.3205784802262,55.15138478627919,2.4020638551848976,10313.642498461768,A1V +Arcturus,36.406178077187505,170.48340920473868,25.39302672914423,4311.564866769375,K1.5III +Castor,51.511786774568165,58.30249455419998,2.4949247676078605,10272.85859821124,A1V +Hadar,350.16977117417395,50002.60389297427,8.905495582568282,24975.362582095524,B1III +Barnard's Star,5.901894921078882,-4.630582788127063,0.21090018348012382,3155.8860822906213,M4Ve +Canopus,309.7238415784254,10503.437168869666,71.09228952861329,7317.65471454349,A9II +Betelgeuse,642.9028035649651,126002.63813670116,886.9150203828822,3484.579523595323,M2Iab +Hadar,349.75553952552616,49998.3383894348,8.914397067696036,24966.92827726474,B1III +Spica,250.255634744821,22000.37954083398,7.352382725473965,25431.214639499387,B1III-IV +Castor,51.98304877115079,50.92786348408169,2.417985940896558,10271.210235736105,A1V +Castor,51.75737010489582,57.52238849379824,2.4920779015828973,10292.92401752005,A1V +Bellatrix,240.00407319071869,6400.714790021413,5.807381329935971,22587.382026560263,B2III +Ross 154,9.496791091141016,1.316544666952884,0.20503510351196566,2788.3174096342764,M3.5V +Mira,417.5275405223786,8697.462716703521,369.99961655471003,2888.6974759473765,M7IIIe +Capella,43.341857133248425,78.46786794169049,11.98310217504998,4905.582672565238,G8III +Wolf 359,7.831985513140465,-4.99314130236977,0.2548533482826728,2775.960243956472,M6V +Aldebaran,65.18394244057998,521.8347764947245,44.1935954632952,3921.426352595788,K5III +Antares,550.0648277783677,9998.226736233071,679.9382321024549,3518.397720580831,M1.5Iab +Altair,16.517311315754984,14.705710668003098,1.540348995279041,7551.720467396224,A7V +Wolf 359,7.842217830165789,-4.305228812321653,0.22405616880392076,2805.7488391086936,M6V +Acrux,321.2232979091321,24998.437363538746,8.436242446261657,28016.765210588765,B0.5IV +Arcturus,36.77774268440709,174.12679191284548,25.324802166033347,4318.010631456625,K1.5III +Bellatrix,240.3954565777999,6403.889346672703,5.847997310190617,22633.827634442634,B2III +Altair,16.81698343653392,8.34484508306073,1.6692319773597764,7557.474773210143,A7V +Canopus,309.85946184517417,10497.374642244886,71.05702456104326,7329.792588143715,A9II +Arcturus,36.28589805029394,169.66102859243858,25.31720535709976,4271.411974908214,K1.5III +Bellatrix,239.66547315750978,6401.015853487317,5.790955517442049,22586.41259528478,B2III +Spica,250.2771634939656,21999.578519001836,7.496551669193757,25440.084674461697,B1III-IV +Procyon,11.183020782895095,11.684858374677258,2.1359560899246253,6532.364672186608,F5IV-V +Capella,43.325316068120735,79.43865609980435,12.067932379343135,4895.335752209808,G8III +Vega,24.84278806610825,44.87302213093578,2.267398407646407,9604.333176201417,A0V +Acrux,320.7563597238534,25001.43969557513,8.461657581508275,28004.31747034558,B0.5IV +Procyon,11.377881859460956,3.1619345383361317,2.1342273758060815,6533.812189342469,F5IV-V +Alpha Centauri B,3.9670753693112197,-3.8509017236860665,0.9178969395621117,5292.942797348222,K1V +Canopus,310.38085606498896,10500.157515440253,71.0379040360618,7384.192277896002,A9II +Altair,16.56786756498236,12.40258131836179,1.7124146821549155,7541.099897210852,A7V +Vega,25.009785593624624,42.61916652521285,2.2818813833402927,9628.22080590828,A0V +Barnard's Star,5.9787983279270085,2.2056294360251103,0.23891428085892485,3092.79861118838,M4Ve +Altair,16.546804536638334,11.60218007055768,1.6934309093439481,7578.471697374213,A7V +Ross 154,10.019988972108159,-0.1663578165081136,0.13158258065782635,2775.738098710297,M3.5V +Wolf 359,7.509380536781729,-4.935052823532525,0.20810934508720413,2841.8905930039778,M6V +Vega,24.803162930467373,41.495367850673475,2.38786013318031,9576.613622627168,A0V +Achernar,143.96622965338523,3150.4177861539374,9.275951222228185,14987.543585054453,B6Vep +Rigil Kentaurus,4.770200191851383,-1.162514750656564,1.2118414077332116,5768.601304291258,G2V +Altair,16.40951171231661,5.689354655912254,1.5920995590519407,7570.6134681372205,A7V +Antares,550.3810400697355,10002.393406132604,679.9207239313258,3533.7117081038605,M1.5Iab +Betelgeuse,642.9506962383331,126002.12138920804,886.9397509430192,3496.4048869047883,M2Iab +Sirius,8.153862547872297,24.17011927398116,1.6264437297161434,9984.21028478672,A1V +Procyon,11.533949262456211,10.77236733632881,2.097725912688288,6576.896042804675,F5IV-V +Ross 154,9.452177745877758,4.97274435570182,0.2634268679578863,2847.679081207114,M3.5V +Canopus,310.1036731709541,10496.109676275262,71.03399407670011,7363.545039774776,A9II +Aldebaran,64.67223541528165,518.712049240274,44.27113890209603,3880.5608200439647,K5III +Arcturus,36.906247750571204,172.01175458304988,25.400060086139366,4266.259021098308,K1.5III +Antares,549.9204623386546,9995.650236150686,680.0291187815914,3507.8845568389456,M1.5Iab +Lalande 21185,8.439597133532216,2.6433710990737387,0.4316383869316258,3365.5018448993296,M2.1V +Barnard's Star,6.187165630701091,4.956944233778123,0.1391027780853812,3145.3595033455963,M4Ve +Barnard's Star,5.621799128520018,3.7760022367690285,0.11319610617868339,3101.014047069934,M4Ve +Castor,51.71998908353143,53.15103578649683,2.321454068721126,10285.43180677566,A1V +Spica,250.40169225874862,22002.935830741622,7.418892400715696,25449.19666587807,B1III-IV +Acrux,320.8089994295918,25004.66014302425,8.301353337284787,28026.52454851035,B0.5IV +Spica,249.87806875875762,22003.593457133502,7.376203984645423,25412.12199277132,B1III-IV +Procyon,10.920471755944988,4.935287891672165,2.0737484014273155,6506.621798818398,F5IV-V +Canopus,309.78529838101207,10500.052904901882,71.02194935754189,7307.0967988732145,A9II +Altair,16.933845755838053,12.845622466715568,1.6974822956589117,7575.06541533419,A7V +Rigil Kentaurus,4.608424065033049,5.00472601467677,1.2929190926560636,5820.262364330082,G2V +Vega,24.65390624701162,41.61042724473538,2.429274022708076,9631.852917163242,A0V +Procyon,11.146881937080314,12.218862119908533,2.0247293672655777,6503.785589850387,F5IV-V +Arcturus,36.3693563748995,167.57770365212474,25.408263436517736,4290.82040736522,K1.5III +Canopus,310.35560420721504,10495.060417002824,71.02611198607457,7336.306359368458,A9II +Altair,16.70733129032844,9.554275564559855,1.5490181205144966,7517.666644153817,A7V +Hadar,350.47273331783754,50002.06465870077,8.940071689517074,25026.854869644325,B1III +Castor,51.94700108831837,51.51081940941651,2.303341519145927,10330.659987471341,A1V +Antares,549.8508372630931,10001.25706401134,680.0627912846477,3497.2764658101314,M1.5Iab +Altair,16.5028339871533,15.00853497168282,1.537143677100781,7531.390715153673,A7V +Ross 154,9.195617903458347,4.002523195559234,0.2331786819378468,2799.1300136375307,M3.5V +Capella,43.28991991209135,78.42806415411815,11.903537314056436,4891.016059207164,G8III +Castor,51.72532804583004,56.68355462603443,2.3156128851403235,10347.251771780268,A1V +Procyon,11.591330421111849,11.923795878328828,2.03384610933756,6515.942047780109,F5IV-V +Lalande 21185,8.703545490785453,3.2554514372729964,0.34371090213467714,3397.560024270192,M2.1V +Mira,417.5482494592996,8697.641481122131,370.0433728646599,2881.4840403317608,M7IIIe +Betelgeuse,642.896853479847,126004.68469642337,886.9879566164066,3511.823072543017,M2Iab +Betelgeuse,642.1716997467348,126001.69509064495,886.9888377279874,3479.277355062287,M2Iab +Lalande 21185,8.731732298435377,4.786238308759169,0.3347032306768086,3382.689040227199,M2.1V +Altair,17.15474181167015,6.975771781193093,1.5483116113750846,7537.641975099961,A7V +Vega,24.776635908276518,35.27153115019188,2.29544479238952,9616.074160949815,A0V +Mira,417.695788448091,8704.185431731014,370.0625415276317,2955.0490698875665,M7IIIe +Rigil Kentaurus,3.996321706725146,1.626551918000496,1.3046574245238987,5794.091339181414,G2V +Mira,418.47024286572923,8702.898481160859,370.0818555771332,2943.151168595254,M7IIIe +Altair,17.111919168917005,10.39101273787362,1.6095873161618377,7504.094812609862,A7V +Altair,16.874372018837036,5.998470578062234,1.5597935011539061,7561.789883494114,A7V +Deneb,2600.0030216501546,195995.4474828539,203.02756825887886,8518.964904807914,A2Ia +Rigel,860.4364002835275,120000.52031072113,78.80303528052436,12131.669640550605,B8Ia +Altair,17.12154390276971,11.776186568379096,1.635310418129086,7555.4180801050825,A7V +Barnard's Star,5.938951989691774,-3.172253923292721,0.2666876758071142,3121.980224966519,M4Ve +Wolf 359,7.455714961927049,-4.43510093589817,0.06808667694271407,2774.1483001662027,M6V +Hadar,350.3016438778805,49997.50659083093,9.070882395506349,25010.502655808556,B1III +Bellatrix,239.7632940871353,6397.02015894308,5.706311488104068,22603.548765755073,B2III +Alpha Centauri B,4.044363778891645,-4.549088213039762,0.9391905375045383,5286.304303993784,K1V +Wolf 359,8.139786203659344,3.484204727275103,0.23632401553344878,2813.6003663283495,M6V diff --git a/tarea/Readme.MD.txt b/tarea/Readme.MD.txt new file mode 100644 index 0000000..e69de29 diff --git a/tarea/Tarea_1.tex b/tarea/Tarea_1.tex new file mode 100644 index 0000000..13fd7cc --- /dev/null +++ b/tarea/Tarea_1.tex @@ -0,0 +1,21 @@ +\documentclass{article} +\usepackage{graphicx} % Required for inserting images + +\title{Ensayo-1 - Programación} +\author{katy Ixchely Yaxón Saloj} +\date{Febrero 2026} + +\begin{document} + +\maketitle +Mi área de interés para investigación en Física se centra en el estudio de los Agujeros negros y la relatividad, su estudio combina la física teórica(singularidades, horizonte de sucesos) con la observación astronómica de rayos X y ondas gravitacionales, describiendo objetos de alta masa que curvan el espacio-tiempo de manera extrema.\\ + + +El estudio de los agujeros negros resulta especialmente relevante porque representa uno de los escenarios más extremos del universo, donde los efectos relativistas son dominantes. Fenómenos como el horizonte de eventos, la dilatación temporal gravitacional, las trayectorias de la luz (geodésicas) y la emisión de ondas gravitacionales solo pueden describirse adecuadamente mediante modelos matemáticos avanzados basados en ecuaciones diferenciales no lineales. En la mayoría de los casos, estas ecuaciones no admiten soluciones analíticas simples, lo que hace necesario el uso de métodos numéricos.\\ + +En este contexto, la programación se convierte en una herramienta fundamental para la investigación. Mediante el uso de lenguajes de programación y algoritmos computacionales es posible resolver numéricamente las ecuaciones de la relatividad general, simular el comportamiento de partículas y campos cerca de un agujero negro, y modelar procesos como la creación de materia o la fusión de objetos compactos. Además, la programación permite analizar datos observacionales reales, como señales de ondas gravitacionales, y compararlos con las predicciones teóricas.\\ + +Finalmente, la programación facilita la visualización de conceptos abstractos, como la curvatura del espacio-tiempo, lo que contribuye tanto a una mejor comprensión física como a la comunicación de resultados científicos. Por estas razones, la combinación de relatividad, agujeros negros y programación constituye un campo de investigación atractivo, actual y esencial dentro de la física moderna.\\ + + +\end{document} diff --git a/tarea/Tarea_1.tex.pdf b/tarea/Tarea_1.tex.pdf new file mode 100644 index 0000000..773490f Binary files /dev/null and b/tarea/Tarea_1.tex.pdf differ diff --git a/tarea/Tarea_4_y_5/Numpy.ipynb b/tarea/Tarea_4_y_5/Numpy.ipynb new file mode 100644 index 0000000..3e70a54 --- /dev/null +++ b/tarea/Tarea_4_y_5/Numpy.ipynb @@ -0,0 +1,1888 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# NumPy — Computación Numérica en Python\n", + "\n", + "## ¿Qué es NumPy?\n", + "\n", + "**NumPy** (Numerical Python) es la librería fundamental para computación científica en Python. Proporciona:\n", + "\n", + "- Un objeto de arreglo (array) multidimensional de alto rendimiento\n", + "- Herramientas para trabajar con estos arreglos\n", + "- Funciones matemáticas, lógicas, de ordenamiento, estadísticas, y más\n", + "\n", + "## ¿Para qué sirve?\n", + "\n", + "| Tarea | Sin NumPy | Con NumPy |\n", + "|---|---|---|\n", + "| Sumar dos listas de 1 millón de elementos | ~0.5 segundos | ~0.005 segundos |\n", + "| Multiplicar matrices | Código complejo con loops | Una línea |\n", + "| Operaciones matemáticas | Loop por cada elemento | Operaciones vectorizadas |\n", + "\n", + "NumPy es la base de casi todas las librerías de ciencia de datos: Pandas, Matplotlib, Scikit-learn, etc." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Instalación e Importación\n", + "\n", + "Para instalar NumPy (si no está instalado):\n", + "```bash\n", + "pip install numpy\n", + "```\n", + "\n", + "Por convención, se importa con el alias `np`:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "NumPy versión: 2.3.3\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "print(\"NumPy versión:\", np.__version__)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## Nivel 1 — Conceptos Básicos: Arrays" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### ¿Qué diferencia hay entre una lista de Python y un array de NumPy?" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Lista Python: [1, 2, 3, 4, 5]\n", + "Tipo: \n", + "\n", + "Array NumPy: [1 2 3 4 5]\n", + "Tipo: \n" + ] + } + ], + "source": [ + "# Lista de Python\n", + "lista = [1, 2, 3, 4, 5]\n", + "print(\"Lista Python:\", lista)\n", + "print(\"Tipo:\", type(lista))\n", + "\n", + "print()\n", + "\n", + "# Array de NumPy\n", + "arreglo = np.array([1, 2, 3, 4, 5])\n", + "print(\"Array NumPy:\", arreglo)\n", + "print(\"Tipo:\", type(arreglo))" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Lista * 3: [1, 2, 3, 1, 2, 3, 1, 2, 3]\n", + "Array * 3: [3 6 9]\n" + ] + } + ], + "source": [ + "# La diferencia clave: operaciones elemento a elemento\n", + "lista_python = [1, 2, 3]\n", + "\n", + "# Con listas, el operador * repite la lista\n", + "print(\"Lista * 3:\", lista_python * 3) # [1, 2, 3, 1, 2, 3, 1, 2, 3]\n", + "\n", + "arreglo_np = np.array([1, 2, 3])\n", + "\n", + "# Con NumPy, * multiplica cada elemento\n", + "print(\"Array * 3:\", arreglo_np * 3) # [3, 6, 9]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### ¿Por qué NumPy es tan rápido? — Comparación de rendimiento\n", + "\n", + "NumPy implementa las operaciones sobre arrays en **código C precompilado**. La misma operación que requiere un ciclo `for` en Python se ejecuta internamente sin ciclos explícitos. Esto se conoce como *código vectorizado* (Stewart & Mommert, §4.1)." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Lista Python : 3.229 segundos\n", + "Array NumPy : 0.122 segundos\n", + "NumPy es 26× más rápido\n" + ] + } + ], + "source": [ + "import time\n", + "\n", + "N = 10_000_000 # 10 millones de elementos\n", + "\n", + "# ── Enfoque con lista Python ──────────────────────────────────────────────────\n", + "a_lista = list(range(N))\n", + "t0 = time.time()\n", + "b_lista = []\n", + "for i in range(len(a_lista)):\n", + " b_lista.append(a_lista[i] + 1)\n", + "t_lista = time.time() - t0\n", + "\n", + "# ── Enfoque con array NumPy ───────────────────────────────────────────────────\n", + "a_np = np.array(a_lista)\n", + "t0 = time.time()\n", + "b_np = a_np + 1 # ← una sola línea, sin ciclo explícito\n", + "t_numpy = time.time() - t0\n", + "\n", + "print(f\"Lista Python : {t_lista:.3f} segundos\")\n", + "print(f\"Array NumPy : {t_numpy:.3f} segundos\")\n", + "print(f\"NumPy es {t_lista / t_numpy:.0f}× más rápido\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Crear arrays de diferentes formas" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ceros: [0. 0. 0. 0. 0.]\n", + "Unos : [1. 1. 1. 1. 1.]\n", + "Vacío: [6.23042070e-307 4.67296746e-307 1.69121096e-306 1.20817917e-311\n", + " 0.00000000e+000]\n", + "\n", + "Arange (0 a 10, paso 2): [0 2 4 6 8]\n", + "Linspace (6 puntos entre 0 y 1): [0. 0.2 0.4 0.6 0.8 1. ]\n", + "Logspace (10^0 a 10^3): [ 1. 10. 100. 1000.]\n", + "\n", + "zeros_like(base): [0 0 0 0 0]\n", + "ones_like(base) : [1 1 1 1 1]\n" + ] + } + ], + "source": [ + "# Array de ceros y unos\n", + "ceros = np.zeros(5)\n", + "unos = np.ones(5)\n", + "vacio = np.empty(5) # sin inicializar — muy rápido, valores arbitrarios\n", + "print(\"Ceros:\", ceros)\n", + "print(\"Unos :\", unos)\n", + "print(\"Vacío:\", vacio)\n", + "\n", + "# Array con rango (como range(), pero retorna array)\n", + "rango = np.arange(0, 10, 2) # inicio, fin (exclusivo), paso\n", + "print(\"\\nArange (0 a 10, paso 2):\", rango)\n", + "\n", + "# N valores igualmente espaciados — escala lineal\n", + "espacio = np.linspace(0, 1, 6) # inicio, fin (inclusivo), N puntos\n", + "print(\"Linspace (6 puntos entre 0 y 1):\", espacio)\n", + "\n", + "# N valores en escala logarítmica (base 10 por defecto)\n", + "log_esp = np.logspace(0, 3, 4) # 10^0 a 10^3, 4 valores\n", + "print(\"Logspace (10^0 a 10^3):\", log_esp)\n", + "\n", + "# Constructores \"look-alike\": misma forma que otro array\n", + "base = np.array([1, 2, 3, 4, 5])\n", + "print(\"\\nzeros_like(base):\", np.zeros_like(base))\n", + "print(\"ones_like(base) :\", np.ones_like(base))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(5,)\n", + "1\n" + ] + } + ], + "source": [ + "print(base.shape)\n", + "print(base.ndim)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Arrays 2D (matrices)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Matriz:\n", + "[[1 2 3]\n", + " [4 5 6]\n", + " [7 8 9]]\n", + "\n", + "Forma (filas x columnas): (3, 3)\n", + "Número de dimensiones: 2\n", + "Total de elementos: 9\n", + "Tipo de dato: int64\n" + ] + } + ], + "source": [ + "# Crear una matriz 2D\n", + "matriz = np.array([\n", + " [1, 2, 3],\n", + " [4, 5, 6],\n", + " [7, 8, 9]\n", + "])\n", + "\n", + "print(\"Matriz:\")\n", + "print(matriz)\n", + "print(\"\\nForma (filas x columnas):\", matriz.shape)\n", + "print(\"Número de dimensiones:\", matriz.ndim)\n", + "print(\"Total de elementos:\", matriz.size)\n", + "print(\"Tipo de dato:\", matriz.dtype)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Tipos de datos (`dtype`) y atributos del array\n", + "\n", + "Todos los elementos de un array NumPy tienen el **mismo tipo de dato** (`dtype`). NumPy infiere el tipo al crear el array, pero puedes especificarlo. Tipos comunes: `int64`, `float64`, `complex128`, `bool`. Puedes convertir con `.astype()` (Stewart & Mommert, §4.1.1)." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dtype inferido: float64\n", + "dtype=int : [1 2 3] → int64\n", + "dtype=complex: [1.+0.j 2.+0.j 3.+0.j] → complex128\n", + "\n", + "x_int.astype(float): [1. 2. 3.] → float64\n", + "\n", + "Array m:\n", + "[[1 2 3]\n", + " [4 5 6]]\n", + " ndim : 2\n", + " shape: (2, 3)\n", + " size : 6\n", + " dtype: int64\n" + ] + } + ], + "source": [ + "x = np.array([1, 2, 3.268999]) # Python convierte todo a float64\n", + "print(\"dtype inferido:\", x.dtype)\n", + "\n", + "# Especificar dtype manualmente\n", + "x_int = np.array([1.5566666666, 2, 3], dtype=int)\n", + "x_cpx = np.array([1, 2, 3], dtype=complex)\n", + "print(\"dtype=int :\", x_int, \"→\", x_int.dtype)\n", + "print(\"dtype=complex:\", x_cpx, \"→\", x_cpx.dtype)\n", + "\n", + "# Convertir dtype con astype()\n", + "x_float = x_int.astype(float)\n", + "print(\"\\nx_int.astype(float):\", x_float, \"→\", x_float.dtype)\n", + "\n", + "# Atributos importantes de un array\n", + "m = np.array([[1, 2, 3], [4, 5, 6]])\n", + "print(\"\\nArray m:\")\n", + "print(m)\n", + "print(\" ndim :\", m.ndim) # número de dimensiones\n", + "print(\" shape:\", m.shape) # (filas, columnas)\n", + "print(\" size :\", m.size) # total de elementos\n", + "print(\" dtype:\", m.dtype) # tipo de dato" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## Nivel 2 — Indexación y Operaciones" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Acceder a elementos (indexación)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Arreglo: [10 20 30 40 50]\n", + "Primer elemento (índice 0): 10\n", + "Último elemento: 50\n", + "Elementos del índice 1 al 3: [20 30 40]\n", + "Cada dos elementos: [10 30 50]\n" + ] + } + ], + "source": [ + "v = np.array([10, 20, 30, 40, 50])\n", + "\n", + "print(\"Arreglo:\", v)\n", + "print(\"Primer elemento (índice 0):\", v[0])\n", + "print(\"Último elemento:\", v[-1])\n", + "print(\"Elementos del índice 1 al 3:\", v[1:4])\n", + "print(\"Cada dos elementos:\", v[::2])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Matriz:\n", + "[[1 2 3]\n", + " [4 5 6]\n", + " [7 8 9]]\n", + "\n", + "Elemento fila 0, columna 1: 2\n", + "Toda la primera fila: [1 2 3]\n", + "Toda la segunda columna: [2 5 8]\n", + "\n", + "Submatriz (filas 0-1, columnas 1-2):\n", + "[[2 3]\n", + " [5 6]]\n" + ] + } + ], + "source": [ + "# Indexación en matrices 2D\n", + "m = np.array([\n", + " [1, 2, 3],\n", + " [4, 5, 6],\n", + " [7, 8, 9]\n", + "])\n", + "\n", + "print(\"Matriz:\")\n", + "print(m)\n", + "print(\"\\nElemento fila 0, columna 1:\", m[0, 1]) # 2\n", + "print(\"Toda la primera fila:\", m[0, :]) # [1, 2, 3]\n", + "print(\"Toda la segunda columna:\", m[:, 1]) # [2, 5, 8]\n", + "print(\"\\nSubmatriz (filas 0-1, columnas 1-2):\")\n", + "print(m[0:2, 1:3])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Indexación booleana (filtrado)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[72 88 91 78]\n", + "Todas las notas: [55 72 88 45 91 63 78]\n", + "Notas > 70: [72 88 91 78]\n", + "Cantidad de aprobados: 4\n", + "Notas en zona (61-70): [63]\n" + ] + } + ], + "source": [ + "notas = np.array([55, 72, 88, 45, 91, 63, 78])\n", + "\n", + "print(notas[notas > 70])\n", + "# ¿Cuáles notas son mayores de 70?\n", + "aprobados = notas[notas > 70]\n", + "print(\"Todas las notas:\", notas)\n", + "print(\"Notas > 70:\", aprobados)\n", + "print(\"Cantidad de aprobados:\", aprobados.shape[0])\n", + "\n", + "# Condición compuesta\n", + "zona = notas[(notas >= 61) & (notas <= 70)]\n", + "print(\"Notas en zona (61-70):\", zona)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Operaciones matemáticas" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a + b = [11 22 33 44]\n", + "a * b = [ 10 40 90 160]\n", + "b / a = [10. 10. 10. 10.]\n", + "a ** 2 = [ 1 4 9 16]\n", + "\n", + "Raíz cuadrada de b: [3.16227766 4.47213595 5.47722558 6.32455532]\n", + "e^a: [ 2.71828183 7.3890561 20.08553692 54.59815003]\n" + ] + } + ], + "source": [ + "a = np.array([1, 2, 3, 4])\n", + "b = np.array([10, 20, 30, 40])\n", + "\n", + "print(\"a + b =\", a + b)\n", + "print(\"a * b =\", a * b)\n", + "print(\"b / a =\", b / a)\n", + "print(\"a ** 2 =\", a ** 2) # Elevar al cuadrado\n", + "print(\"\\nRaíz cuadrada de b:\", np.sqrt(b))\n", + "print(\"e^a:\", np.exp(a))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Broadcasting — reglas para operar arrays de distinta forma\n", + "\n", + "Cuando aplicas una operación entre un array y un escalar (o dos arrays de forma distinta), NumPy ajusta los tamaños automáticamente siguiendo **dos reglas** (Stewart & Mommert, §4.1.4):\n", + "\n", + "1. **Regla 1** — Si los arrays tienen distinto número de dimensiones, la forma del más pequeño se *extiende* a la izquierda con \"1\" hasta igualar.\n", + "2. **Regla 2** — Un eje de tamaño 1 se comporta como si tuviera el tamaño del eje más grande en esa dimensión (se \"replica\").\n", + "\n", + "```\n", + "array → [1, 2, 3, 4, 5] forma: (5,)\n", + "escalar → 10 forma: () → (1,) → (5,) [reglas 1 y 2]\n", + "resultado→ [11, 12, 13, 14, 15]\n", + "```\n", + "\n", + "Si dos ejes no son 1 y son distintos entre sí → **ValueError** (no se puede hacer broadcast)." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Array original: [1 2 3 4 5]\n", + "v + 10 : [11 12 13 14 15]\n", + "v * 3 : [ 3 6 9 12 15]\n", + "v ** 2 : [ 1 4 9 16 25]\n", + "v / 2 : [0.5 1. 1.5 2. 2.5]\n", + "v - 1 : [0 1 2 3 4]\n", + "\n", + "Matriz + 100:\n", + "[[101 102 103]\n", + " [104 105 106]]\n", + "\n", + "Matriz * 2:\n", + "[[ 2 4 6]\n", + " [ 8 10 12]]\n" + ] + } + ], + "source": [ + "v = np.array([1, 2, 3, 4, 5])\n", + "\n", + "print(\"Array original:\", v)\n", + "print(\"v + 10 :\", v + 10) # suma 10 a cada elemento\n", + "print(\"v * 3 :\", v * 3) # multiplica cada elemento por 3\n", + "print(\"v ** 2 :\", v ** 2) # eleva al cuadrado cada elemento\n", + "print(\"v / 2 :\", v / 2) # divide cada elemento entre 2\n", + "print(\"v - 1 :\", v - 1)\n", + "\n", + "# También funciona con matrices\n", + "m = np.array([[1, 2, 3],\n", + " [4, 5, 6]])\n", + "print(\"\\nMatriz + 100:\")\n", + "print(m + 100)\n", + "print(\"\\nMatriz * 2:\")\n", + "print(m * 2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Funciones matemáticas (ufuncs)\n", + "\n", + "NumPy tiene versiones de las funciones matemáticas de `math` que funcionan directamente sobre **arrays completos** sin necesidad de un ciclo `for`. Estas se llaman *ufuncs* (universal functions)." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "x : [0 1 2 3 4 5]\n", + "np.sqrt(x) : [0. 1. 1.41421356 1.73205081 2. 2.23606798]\n", + "np.exp(x) : [ 1. 2.71828183 7.3890561 20.08553692 54.59815003\n", + " 148.4131591 ]\n", + "np.log(x+1): [0. 0.69314718 1.09861229 1.38629436 1.60943791 1.79175947]\n", + "np.abs(x-3): [3 2 1 0 1 2]\n", + "np.sign(x-3): [-1 -1 -1 0 1 1]\n" + ] + } + ], + "source": [ + "x = np.array([0, 1, 2, 3, 4, 5])\n", + "\n", + "print(\"x :\", x)\n", + "print(\"np.sqrt(x) :\", np.sqrt(x)) # raíz cuadrada de cada elemento\n", + "print(\"np.exp(x) :\", np.exp(x)) # e^x\n", + "print(\"np.log(x+1):\", np.log(x + 1)) # logaritmo natural (evitamos log(0))\n", + "print(\"np.abs(x-3):\", np.abs(x - 3)) # valor absoluto\n", + "print(\"np.sign(x-3):\", np.sign(x - 3)) # -1, 0 o 1 según el signo" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ángulos (rad): [0. 0.5236 0.7854 1.0472 1.5708]\n", + "sin : [0. 0.5 0.7071 0.866 1. ]\n", + "cos : [1. 0.866 0.7071 0.5 0. ]\n", + "\n", + "Velocidad vertical (v0=10): [ 0. 5. 7.071 8.66 10. ]\n" + ] + } + ], + "source": [ + "# Funciones trigonométricas (el argumento está en radianes)\n", + "angulos = np.array([0, np.pi/6, np.pi/4, np.pi/3, np.pi/2])\n", + "\n", + "print(\"Ángulos (rad):\", angulos.round(4))\n", + "print(\"sin :\", np.sin(angulos).round(4))\n", + "print(\"cos :\", np.cos(angulos).round(4))\n", + "\n", + "# Caso práctico: calcular la componente vertical de lanzamientos\n", + "# con distintos ángulos y velocidad inicial v0 = 10 m/s\n", + "v0 = 10\n", + "v_vertical = v0 * np.sin(angulos)\n", + "print(\"\\nVelocidad vertical (v0=10):\", v_vertical.round(3))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## Nivel 3b — Valores especiales y operadores lógicos\n", + "\n", + "### Valores especiales: `nan` e `inf`\n", + "\n", + "Algunas operaciones producen resultados especiales:\n", + "- `np.nan` (*Not a Number*): resultado indefinido, como `log(-1)` o `0/0`\n", + "- `np.inf` (*infinito*): resultado de dividir un número entre cero\n", + "\n", + "NumPy tiene versiones de las funciones estadísticas que **ignoran** los `nan`:\n", + "`np.nanmean`, `np.nansum`, `np.nanmax`, `np.nanmin`" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "np.pi = 3.141592653589793\n", + "np.e = 2.718281828459045\n", + "np.inf = inf\n", + "np.nan = nan\n", + "\n", + "sqrt de [-4. -1. 0. 1. 4.] → [nan nan 0. 1. 2.]\n", + "\n", + "Notas con nan: [85. nan 72. nan 91.]\n", + "Media normal : nan\n", + "Media sin nan : 82.66666666666667\n", + "Suma sin nan : 248.0\n" + ] + } + ], + "source": [ + "print(\"np.pi =\", np.pi)\n", + "print(\"np.e =\", np.e)\n", + "print(\"np.inf =\", np.inf)\n", + "print(\"np.nan =\", np.nan)\n", + "\n", + "# nan aparece en operaciones indefinidas\n", + "x = np.array([-4.0, -1.0, 0.0, 1.0, 4.0])\n", + "\n", + "# Evitar warning: reemplazar negativos por nan antes de sqrt\n", + "x_safe = np.where(x < 0, np.nan, x)\n", + "print(\"\\nsqrt de\", x, \"→\", np.sqrt(x_safe)) # ya no genera warning\n", + "\n", + "# Funciones que ignoran nan\n", + "notas = np.array([85.0, np.nan, 72.0, np.nan, 91.0])\n", + "print(\"\\nNotas con nan:\", notas)\n", + "print(\"Media normal :\", np.mean(notas)) # devuelve nan\n", + "print(\"Media sin nan :\", np.nanmean(notas)) # ignora nan\n", + "print(\"Suma sin nan :\", np.nansum(notas))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Operadores lógicos sobre arrays\n", + "\n", + "Puedes comparar un array con un valor y obtienes un array de booleanos (`True`/`False`).\n", + "Luego ese array booleano puede usarse como filtro para seleccionar elementos." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Temperaturas: [18.5 22. 35.1 15.3 28.7 12. 30. ]\n", + "temps > 25 : [False False True False True False True]\n", + "\n", + "Días calurosos (> 25°C): [35.1 28.7 30. ]\n", + "Días moderados (20-30°C): [22. 28.7 30. ]\n", + "\n", + "¿Cuántos días > 25?: 3\n", + "¿Algún día < 10? : False\n", + "¿Todos > 10? : True\n" + ] + } + ], + "source": [ + "temps = np.array([18.5, 22.0, 35.1, 15.3, 28.7, 12.0, 30.0])\n", + "\n", + "# Comparación → array de True/False\n", + "print(\"Temperaturas:\", temps)\n", + "print(\"temps > 25 :\", temps > 25)\n", + "\n", + "# Usar el array booleano para filtrar\n", + "calurosos = temps[temps > 25]\n", + "print(\"\\nDías calurosos (> 25°C):\", calurosos)\n", + "\n", + "# Condición compuesta: & (y) , | (o)\n", + "moderados = temps[(temps >= 20) & (temps <= 30)]\n", + "print(\"Días moderados (20-30°C):\", moderados)\n", + "\n", + "# Contar cuántos cumplen la condición\n", + "print(\"\\n¿Cuántos días > 25?:\", np.sum(temps > 25))\n", + "print(\"¿Algún día < 10? :\", np.any(temps < 10))\n", + "print(\"¿Todos > 10? :\", np.all(temps > 10))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### `np.where` — asignar valores según condición\n", + "\n", + "`np.where(condición, valor_si_True, valor_si_False)` crea un array nuevo aplicando una regla a cada elemento. Es el equivalente vectorizado del operador ternario." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Nota 55 → Reprobado\n", + " Nota 72 → Aprobado\n", + " Nota 88 → Aprobado\n", + " Nota 45 → Reprobado\n", + " Nota 91 → Aprobado\n", + " Nota 63 → Aprobado\n", + " Nota 78 → Aprobado\n", + "\n", + "Notas penalizadas: [ 0 72 88 0 91 63 78]\n" + ] + } + ], + "source": [ + "notas = np.array([55, 72, 88, 45, 91, 63, 78])\n", + "\n", + "# Etiquetar cada nota como \"Aprobado\" o \"Reprobado\"\n", + "estados = np.where(notas >= 61, \"Aprobado\", \"Reprobado\")\n", + "\n", + "for n, e in zip(notas, estados):\n", + " print(f\" Nota {n:3d} → {e}\")\n", + "\n", + "# También funciona con números\n", + "# Reemplazar notas menores a 61 con 0 (para penalización)\n", + "penalizadas = np.where(notas >= 61, notas, 0)\n", + "print(\"\\nNotas penalizadas:\", penalizadas)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Copias vs Vistas (*views*) — diferencia crítica con listas\n", + "\n", + "En NumPy existen **tres comportamientos** distintos al \"asignar\" un array:\n", + "\n", + "| Operación | Resultado | Modifica original |\n", + "|---|---|---|\n", + "| `b = a` | **alias** — misma memoria | Sí |\n", + "| `b = a[1:4]` | **vista** (*view*) — misma memoria | **Sí** ⚠️ |\n", + "| `b = a.copy()` | **copia** — memoria nueva | No |\n", + "\n", + "> **¡Diferencia clave con listas!** En Python, `l[1:4]` es siempre una copia. En NumPy, `a[1:4]` es una **vista** del array original — modificarla cambia el original. Esto es fuente frecuente de errores (Stewart & Mommert, §4.1.2)." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Alias modifica 'original': [999 2 3 4 5]\n", + "Slice (vista) modifica 'original2': [ 1 777 3 4 5]\n", + "Copia NO modifica 'original3': [1 2 3 4 5]\n" + ] + } + ], + "source": [ + "original = np.array([1, 2, 3, 4, 5])\n", + "\n", + "# ⚠ ALIAS — dos nombres, un solo array\n", + "alias = original\n", + "alias[0] = 999\n", + "print(\"Alias modifica 'original':\", original)\n", + "\n", + "# ⚠ VISTA (slice) — ¡diferente a listas Python!\n", + "original2 = np.array([1, 2, 3, 4, 5])\n", + "vista = original2[1:4] # NO es copia — es vista\n", + "vista[0] = 777\n", + "print(\"Slice (vista) modifica 'original2':\", original2)\n", + "\n", + "# ✅ COPIA independiente — usa .copy()\n", + "original3 = np.array([1, 2, 3, 4, 5])\n", + "copia = original3.copy()\n", + "copia[0] = 999\n", + "print(\"Copia NO modifica 'original3':\", original3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Unir arrays — concatenate, hstack, vstack, stack\n", + "\n", + "NumPy ofrece varias formas de unir arrays (Stewart & Mommert, §4.1.5):\n", + "\n", + "- `np.concatenate()`: función **general** — une a lo largo de un eje existente.\n", + "- `np.hstack()`: atajo para unir **horizontalmente** (eje 1 en 2D, eje 0 en 1D).\n", + "- `np.vstack()`: atajo para unir **verticalmente** (eje 0).\n", + "- `np.stack()`: apila creando un **nuevo eje**." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "concatenate: [1 2 3 4 5 6]\n", + "hstack : [1 2 3 4 5 6]\n", + "\n", + "vstack (apilar filas, axis=0):\n", + "[[1 2]\n", + " [3 4]\n", + " [5 6]\n", + " [7 8]]\n", + "\n", + "hstack (unir columnas, axis=1):\n", + "[[1 2 5 6]\n", + " [3 4 7 8]]\n", + "\n", + "stack — crea NUEVO eje (shape resultante: 2×2×2):\n", + "[[[1 2]\n", + " [3 4]]\n", + "\n", + " [[5 6]\n", + " [7 8]]]\n", + "Shape: (2, 2, 2)\n" + ] + } + ], + "source": [ + "a = np.array([1, 2, 3])\n", + "b = np.array([4, 5, 6])\n", + "\n", + "# Función general: np.concatenate\n", + "print(\"concatenate:\", np.concatenate((a, b)))\n", + "print(\"hstack :\", np.hstack((a, b))) # equivalente para 1D\n", + "\n", + "# Para matrices\n", + "m1 = np.array([[1, 2], [3, 4]])\n", + "m2 = np.array([[5, 6], [7, 8]])\n", + "\n", + "print(\"\\nvstack (apilar filas, axis=0):\")\n", + "print(np.vstack((m1, m2)))\n", + "\n", + "print(\"\\nhstack (unir columnas, axis=1):\")\n", + "print(np.hstack((m1, m2)))\n", + "\n", + "print(\"\\nstack — crea NUEVO eje (shape resultante: 2×2×2):\")\n", + "apilado = np.stack((m1, m2), axis=0)\n", + "print(apilado)\n", + "print(\"Shape:\", apilado.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Ordenar y buscar — `np.sort` y `np.argsort`\n", + "\n", + "- `np.sort(x)` — retorna una **copia ordenada** (no modifica `x`).\n", + "- `np.argsort(x)` — retorna los **índices** que ordenarían `x`. Muy útil para ordenar arrays relacionados (e.g., ordenar nombres por nota) (Stewart & Mommert, §4.2.5)." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Notas originales: [78 45 92 61 88 34 73]\n", + "Ordenadas (asc) : [34 45 61 73 78 88 92]\n", + "Ordenadas (desc): [92 88 78 73 61 45 34]\n", + "\n", + "Índices (argsort): [5 1 3 6 0 4 2]\n", + "Aplicando índices : [34 45 61 73 78 88 92]\n", + "\n", + "Ranking:\n", + " 1. Diana: 92\n", + " 2. Fátima: 88\n", + " 3. Ana: 78\n", + " 4. Helena: 73\n", + " 5. Eduardo: 61\n", + " 6. Carlos: 45\n", + " 7. Gabriel: 34\n" + ] + } + ], + "source": [ + "notas = np.array([78, 45, 92, 61, 88, 34, 73])\n", + "print(\"Notas originales:\", notas)\n", + "\n", + "# np.sort — retorna una copia ordenada (no modifica el original)\n", + "print(\"Ordenadas (asc) :\", np.sort(notas))\n", + "print(\"Ordenadas (desc):\", np.sort(notas)[::-1])\n", + "\n", + "# np.argsort — retorna los ÍNDICES que ordenarían el array\n", + "indices = np.argsort(notas)\n", + "print(\"\\nÍndices (argsort):\", indices)\n", + "print(\"Aplicando índices :\", notas[indices]) # equivale a sort\n", + "\n", + "# Caso práctico: obtener ranking de estudiantes\n", + "nombres = np.array([\"Ana\", \"Carlos\", \"Diana\", \"Eduardo\", \"Fátima\", \"Gabriel\", \"Helena\"])\n", + "ranking = np.argsort(notas)[::-1] # mayor a menor\n", + "print(\"\\nRanking:\")\n", + "for pos, i in enumerate(ranking, 1):\n", + " print(f\" {pos}. {nombres[i]}: {notas[i]}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Suma acumulativa — `np.cumsum`\n", + "\n", + "`np.cumsum` calcula la suma acumulada: cada elemento del resultado es la suma de todos los anteriores más el actual. Útil para calcular totales progresivos (gastos, puntajes acumulados, etc.)." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Puntos por nivel : [100 250 180 320 210]\n", + "Puntos acumulados : [ 100 350 530 850 1060]\n", + "\n", + "Gastos diarios : [ 50 120 30 85 200 45]\n", + "Total acumulado : [ 50 170 200 285 485 530]\n", + "Total de la semana : 530\n" + ] + } + ], + "source": [ + "puntos_por_nivel = np.array([100, 250, 180, 320, 210])\n", + "\n", + "print(\"Puntos por nivel :\", puntos_por_nivel)\n", + "print(\"Puntos acumulados :\", np.cumsum(puntos_por_nivel))\n", + "\n", + "# Ejemplo: gastos diarios y total acumulado\n", + "gastos = np.array([50, 120, 30, 85, 200, 45])\n", + "print(\"\\nGastos diarios :\", gastos)\n", + "print(\"Total acumulado :\", np.cumsum(gastos))\n", + "print(\"Total de la semana :\", np.sum(gastos))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## Nivel 3 — Estadística y Álgebra Lineal" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Funciones estadísticas" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Datos: [23 45 12 67 34 89 56 78 90 11]\n", + "\n", + "--- Estadísticas ---\n", + "Mínimo: 11\n", + "Máximo: 90\n", + "Suma: 505\n", + "Media (promedio): 50.50\n", + "Mediana: 50.50\n", + "Desviación estándar: 28.64\n", + "Varianza: 820.25\n", + "\n", + "Índice del máximo: 8\n", + "Índice del mínimo: 9\n" + ] + } + ], + "source": [ + "datos = np.array([23, 45, 12, 67, 34, 89, 56, 78, 90, 11])\n", + "\n", + "print(\"Datos:\", datos)\n", + "print(\"\\n--- Estadísticas ---\")\n", + "print(f\"Mínimo: {np.min(datos)}\")\n", + "print(f\"Máximo: {np.max(datos)}\")\n", + "print(f\"Suma: {np.sum(datos)}\")\n", + "print(f\"Media (promedio): {np.mean(datos):.2f}\")\n", + "print(f\"Mediana: {np.median(datos):.2f}\")\n", + "print(f\"Desviación estándar: {np.std(datos):.2f}\")\n", + "print(f\"Varianza: {np.var(datos):.2f}\")\n", + "print(f\"\\nÍndice del máximo: {np.argmax(datos)}\")\n", + "print(f\"Índice del mínimo: {np.argmin(datos)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Estadísticas avanzadas — histograma, media ponderada, correlación\n", + "\n", + "- `np.histogram(x, bins)` — distribución de frecuencias (retorna conteo y bordes).\n", + "- `np.average(x, weights=w)` — **media ponderada** (cada dato tiene un peso diferente).\n", + "- `np.corrcoef(x, y)` — **coeficiente de correlación** de Pearson entre dos arrays.\n", + "- **API moderna de números aleatorios**: usar `default_rng(semilla)` en lugar de `np.random.seed()` (Stewart & Mommert, §4.4)." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Conteo por intervalo: [ 6 16 31 44 39 39 12 9 3 1]\n", + "Bordes de intervalos: [48.7 53.7 58.8 63.8 68.9 73.9 79. 84. 89. 94.1 99.1]\n", + "\n", + "Media simple : 2.86\n", + "Media ponderada : 2.995\n", + "\n", + "Coeficiente de correlación Pearson:\n", + "[[1. 0.9987]\n", + " [0.9987 1. ]]\n" + ] + } + ], + "source": [ + "from numpy.random import default_rng\n", + "rng = default_rng(42) # semilla para reproducibilidad\n", + "\n", + "# Generar datos con distribución normal (media=70, desv=10)\n", + "calificaciones = rng.normal(loc=70, scale=10, size=200).clip(0, 100)\n", + "\n", + "# np.histogram — distribución de frecuencias\n", + "conteo, bordes = np.histogram(calificaciones, bins=10)\n", + "print(\"Conteo por intervalo:\", conteo)\n", + "print(\"Bordes de intervalos:\", bordes.round(1))\n", + "\n", + "# Media ponderada: notas con distintos pesos\n", + "mediciones = np.array([3.1, 2.7, 2.5, 3.1, 2.9])\n", + "incertidumbres = np.array([0.05, 0.15, 0.60, 0.10, 0.05])\n", + "print(\"\\nMedia simple :\", np.mean(mediciones).round(4))\n", + "print(\"Media ponderada :\", np.average(mediciones, weights=1/incertidumbres**2).round(4))\n", + "# Pesos = 1/σ² → mayor peso a mediciones más precisas\n", + "\n", + "# Correlación entre dos arrays\n", + "x = np.array([1, 2, 3, 4, 5])\n", + "y = np.array([2.1, 3.9, 6.2, 7.8, 10.1])\n", + "print(\"\\nCoeficiente de correlación Pearson:\")\n", + "print(np.corrcoef(x, y).round(4))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Reshape — cambiar la forma de un array" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Arreglo original: [ 1 2 3 4 5 6 7 8 9 10 11 12]\n", + "Forma: (12,)\n", + "\n", + "Reorganizado a 3x4:\n", + "[[ 1 2 3 4]\n", + " [ 5 6 7 8]\n", + " [ 9 10 11 12]]\n", + "\n", + "Reorganizado a 2x6:\n", + "[[ 1 2 3 4 5 6]\n", + " [ 7 8 9 10 11 12]]\n" + ] + } + ], + "source": [ + "# Crear un arreglo de 12 elementos y reorganizarlo\n", + "v = np.arange(1, 13)\n", + "print(\"Arreglo original:\", v)\n", + "print(\"Forma:\", v.shape)\n", + "\n", + "# Convertir a matriz 3x4\n", + "m = v.reshape(3, 4)\n", + "print(\"\\nReorganizado a 3x4:\")\n", + "print(m)\n", + "\n", + "# Convertir a matriz 2x6\n", + "print(\"\\nReorganizado a 2x6:\")\n", + "print(v.reshape(2, 6))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Multiplicación de matrices y operaciones esenciales\n", + "\n", + "| Operación | Sintaxis | Descripción |\n", + "|---|---|---|\n", + "| Elemento a elemento | `A * B` | Hadamard product |\n", + "| Matricial | `A @ B` o `np.matmul(A, B)` | Producto matricial |\n", + "| Transpuesta | `A.T` o `np.transpose(A)` | Intercambia filas↔columnas |\n", + "| Identidad | `np.identity(n)` | Matriz identidad n×n |\n", + "| Aplanar | `A.ravel()` o `np.ravel(A)` | Convierte a vector 1D |" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "A * B (elemento a elemento):\n", + "[[ 5 12]\n", + " [21 32]]\n", + "\n", + "A @ B (multiplicación matricial):\n", + "[[19 22]\n", + " [43 50]]\n", + "\n", + "A.T (transpuesta):\n", + "[[1 3]\n", + " [2 4]]\n", + "\n", + "np.identity(3) — matriz identidad:\n", + "[[1. 0. 0.]\n", + " [0. 1. 0.]\n", + " [0. 0. 1.]]\n", + "\n", + "A.ravel() — aplanar a 1D: [1 2 3 4]\n" + ] + } + ], + "source": [ + "A = np.array([[1, 2], [3, 4]])\n", + "B = np.array([[5, 6], [7, 8]])\n", + "\n", + "print(\"A * B (elemento a elemento):\")\n", + "print(A * B)\n", + "\n", + "print(\"\\nA @ B (multiplicación matricial):\")\n", + "print(A @ B)\n", + "\n", + "print(\"\\nA.T (transpuesta):\")\n", + "print(A.T)\n", + "\n", + "print(\"\\nnp.identity(3) — matriz identidad:\")\n", + "print(np.identity(3))\n", + "\n", + "# Aplanar una matriz a vector 1D\n", + "print(\"\\nA.ravel() — aplanar a 1D:\", A.ravel())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## Nivel 3d — Álgebra Lineal (`numpy.linalg`)\n", + "\n", + "NumPy incluye el módulo `numpy.linalg` (importado como `la`) para operaciones matriciales avanzadas (Stewart & Mommert, §4.7):\n", + "\n", + "| Función | Descripción |\n", + "|---|---|\n", + "| `la.det(A)` | Determinante de A |\n", + "| `la.inv(A)` | Inversa de A (si det ≠ 0) |\n", + "| `la.norm(v)` | Norma euclidiana de un vector |\n", + "| `la.solve(A, b)` | Resuelve el sistema **Ax = b** |\n", + "| `la.eig(A)` | Eigenvalores y eigenvectores de A |\n", + "\n", + "> `la.solve(A, b)` es numéricamente más estable y eficiente que calcular `la.inv(A) @ b`." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Matriz A:\n", + "[[4. 2. 0.]\n", + " [9. 3. 7.]\n", + " [1. 2. 1.]]\n", + "\n", + "Determinante: -48.0\n", + "\n", + "Inversa A⁻¹:\n", + "[[ 0.2292 0.0417 -0.2917]\n", + " [ 0.0417 -0.0833 0.5833]\n", + " [-0.3125 0.125 0.125 ]]\n", + "\n", + "A @ A⁻¹ (≈ identidad):\n", + "[[1. 0. 0.]\n", + " [0. 1. 0.]\n", + " [0. 0. 1.]]\n", + "\n", + "Norma del vector [3, 4]: 5.0\n" + ] + } + ], + "source": [ + "import numpy.linalg as la\n", + "\n", + "A = np.array([[4, 2, 0],\n", + " [9, 3, 7],\n", + " [1, 2, 1]], dtype=float)\n", + "\n", + "print(\"Matriz A:\")\n", + "print(A)\n", + "\n", + "# Determinante\n", + "print(\"\\nDeterminante:\", la.det(A).round(4))\n", + "\n", + "# Inversa (si det ≠ 0)\n", + "A_inv = la.inv(A)\n", + "print(\"\\nInversa A⁻¹:\")\n", + "print(A_inv.round(4))\n", + "\n", + "# Verificación: A @ A⁻¹ debe ser la identidad\n", + "print(\"\\nA @ A⁻¹ (≈ identidad):\")\n", + "print((A @ A_inv).round(10))\n", + "\n", + "# Norma de un vector\n", + "v = np.array([3.0, 4.0])\n", + "print(\"\\nNorma del vector [3, 4]:\", la.norm(v)) # = 5.0" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solución x: [ 1. 2. -2.]\n", + "Verificación Ax - b ≈ 0: [ 0. 0. -0.]\n", + "\n", + "--- Eigenvalores ---\n", + "Eigenvalores: [-5. 3. 6.]\n", + "Primer eigenvector: [ 0.816 0.408 -0.408]\n" + ] + } + ], + "source": [ + "import numpy.linalg as la\n", + "\n", + "# ─── Resolución de sistemas de ecuaciones: Ax = b ───────────────────────────\n", + "# Ejemplo: sistema de 3 ecuaciones\n", + "# 3x + 2y + z = 5\n", + "# 5x + 5y + 5z = 5\n", + "# x + 4y + 6z = -3\n", + "A = np.array([[3, 2, 1],\n", + " [5, 5, 5],\n", + " [1, 4, 6]], dtype=float)\n", + "b = np.array([5, 5, -3], dtype=float)\n", + "\n", + "x = la.solve(A, b)\n", + "print(\"Solución x:\", x.round(4))\n", + "print(\"Verificación Ax - b ≈ 0:\", (A @ x - b).round(10))\n", + "\n", + "# ─── Eigenvalores y eigenvectores ───────────────────────────────────────────\n", + "print(\"\\n--- Eigenvalores ---\")\n", + "M = np.array([[-2, -4, 2],\n", + " [-2, 1, 2],\n", + " [ 4, 2, 5]], dtype=float)\n", + "eigenvalores, eigenvectores = la.eig(M)\n", + "print(\"Eigenvalores:\", eigenvalores.round(3))\n", + "print(\"Primer eigenvector:\", eigenvectores[:, 0].round(3))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## Nivel 3e — Polinomios\n", + "\n", + "NumPy permite representar polinomios por sus coeficientes y ofrece funciones para ajustar, evaluar y manipularlos (Stewart & Mommert, §4.6):\n", + "\n", + "- `np.polyfit(x, y, deg)` — ajusta un polinomio de grado `deg` a datos *(x, y)* por mínimos cuadrados. Retorna los coeficientes `[a_n, ..., a_1, a_0]`.\n", + "- `np.polyval(coefs, x)` — evalúa el polinomio con coeficientes `coefs` en los puntos `x`.\n", + "- `np.poly(roots)` — construye coeficientes desde las raíces.\n", + "- `np.roots(coefs)` — calcula las raíces a partir de los coeficientes." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Coeficientes [a, b, c]: [ 0.051 -0. 0. ]\n", + "Modelo: d = 0.0510·v² + -0.0000·v + 0.0000\n", + "\n", + "Predicciones:\n", + " v=25 m/s → d≈31.88 m\n", + " v=35 m/s → d≈62.48 m\n", + " v=45 m/s → d≈103.28 m\n" + ] + } + ], + "source": [ + "# Datos: velocidad inicial vs distancia máxima (proyectil simplificado)\n", + "# Queremos ajustar un polinomio de grado 2: d = a*v^2 + b*v + c\n", + "v = np.array([10, 20, 30, 40, 50], dtype=float) # velocidad (m/s)\n", + "d = np.array([5.1, 20.4, 45.9, 81.6, 127.5]) # distancia (m)\n", + "\n", + "# np.polyfit: ajuste de mínimos cuadrados\n", + "coefs = np.polyfit(v, d, deg=2)\n", + "print(\"Coeficientes [a, b, c]:\", coefs.round(4))\n", + "print(f\"Modelo: d = {coefs[0]:.4f}·v² + {coefs[1]:.4f}·v + {coefs[2]:.4f}\")\n", + "\n", + "# np.polyval: evaluar el polinomio en nuevos valores\n", + "v_nuevo = np.array([25, 35, 45])\n", + "d_pred = np.polyval(coefs, v_nuevo)\n", + "print(\"\\nPredicciones:\")\n", + "for vi, di in zip(v_nuevo, d_pred):\n", + " print(f\" v={vi} m/s → d≈{di:.2f} m\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## Nivel 4 — Ejemplo Aplicado: Cálculo de Notas" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Notas (Tarea1 | Tarea2 | Parcial | Final):\n", + "--------------------------------------------------\n", + "Ana [78 91 68 54]\n", + "Carlos [ 82 47 100 60]\n", + "Diana [78 97 58 62]\n", + "Eduardo [50 50 63 92]\n", + "Fátima [75 79 63 42]\n", + "Gabriel [61 92 41 63]\n", + "Helena [83 69 77 41]\n", + "Iván [99 60 72 51]\n", + "\n", + "--- Resultados Finales ---\n", + "Ana Nota: 67.3 → APROBADO\n", + "Carlos Nota: 73.3 → APROBADO\n", + "Diana Nota: 68.5 → APROBADO\n", + "Eduardo Nota: 70.7 → APROBADO\n", + "Fátima Nota: 58.8 → REPROBADO\n", + "Gabriel Nota: 60.5 → REPROBADO\n", + "Helena Nota: 62.3 → APROBADO\n", + "Iván Nota: 65.8 → APROBADO\n", + "\n", + "Promedio del curso: 65.91\n", + "Nota más alta: 73.35\n", + "Nota más baja: 58.80\n", + "Aprobados: 6 / 8\n" + ] + } + ], + "source": [ + "# Simulación de notas de un curso\n", + "# Filas = estudiantes, Columnas = [Tarea1, Tarea2, Examen parcial, Examen final]\n", + "np.random.seed(42) # Para reproducibilidad\n", + "\n", + "notas = np.random.randint(40, 101, size=(8, 4))\n", + "pesos = np.array([0.15, 0.15, 0.30, 0.40]) # Pesos de cada evaluación\n", + "\n", + "nombres = [\"Ana\", \"Carlos\", \"Diana\", \"Eduardo\", \"Fátima\", \"Gabriel\", \"Helena\", \"Iván\"]\n", + "\n", + "print(\"Notas (Tarea1 | Tarea2 | Parcial | Final):\")\n", + "print(\"-\" * 50)\n", + "for nombre, fila in zip(nombres, notas):\n", + " print(f\"{nombre:<10} {fila}\")\n", + "\n", + "# Calcular nota final ponderada para cada estudiante\n", + "notas_finales = notas @ pesos\n", + "\n", + "print(\"\\n--- Resultados Finales ---\")\n", + "for nombre, nota in zip(nombres, notas_finales):\n", + " estado = \"APROBADO\" if nota >= 61 else \"REPROBADO\"\n", + " print(f\"{nombre:<10} Nota: {nota:.1f} → {estado}\")\n", + "\n", + "print(f\"\\nPromedio del curso: {np.mean(notas_finales):.2f}\")\n", + "print(f\"Nota más alta: {np.max(notas_finales):.2f}\")\n", + "print(f\"Nota más baja: {np.min(notas_finales):.2f}\")\n", + "print(f\"Aprobados: {np.sum(notas_finales >= 61)} / {len(notas_finales)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tarea 4 — NumPy en Práctica\n", + "\n", + "La programación se aprende haciendo, no leyendo. Esta tarea tiene dos partes:\n", + "\n", + "**Parte 1 — Descarga y ejecuta** (obligatorio)\n", + "Descarga este notebook y ejecútalo celda por celda en tu computadora. \n", + "Asegúrate de que todas las celdas corran sin errores antes de continuar.\n", + "\n", + "**Parte 2 — Ejercicios** (obligatorio) \n", + "Completa cada celda que dice `# TU CÓDIGO AQUÍ` con tu solución. \n", + "Ejecuta la celda para verificar que el resultado es correcto.\n", + "\n", + "**Entrega: 1 de mayo** \n", + "Sube el notebook a tu repositorio de GitHub y envía el **link directo al archivo `.ipynb`**.\n", + "El notebook debe tener todas las celdas ya ejecutadas (con outputs visibles).\n", + "\n", + "Ejemplo de link válido: \n", + "`https://github.com/tu-usuario/tu-repo/blob/main/Numpy.ipynb`" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Ejercicio 1 — Crear y operar arrays\n", + "\n", + "Crea un array con los números del 1 al 10 usando `np.arange`. \n", + "Luego calcula e imprime:\n", + "- Cada número multiplicado por 5\n", + "- Solo los números pares (usa indexación booleana)\n", + "- La suma de todos los números" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "x5: [ 5 10 15 20 25 30 35 40 45 50]\n", + "Pares: [ 2 4 6 8 10]\n", + "Suma: 55\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "arr = np.arange(1, 11)\n", + "\n", + "print(\"x5:\", arr * 5)\n", + "print(\"Pares:\", arr[arr % 2 == 0])\n", + "print(\"Suma:\", np.sum(arr))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Ejercicio 2 — Funciones matemáticas\n", + "\n", + "Dado el array de ángulos en grados, conviértelos a radianes y calcula su seno. \n", + "Fórmula: `radianes = grados * π / 180`\n", + "\n", + "Ángulos: 0°, 30°, 45°, 60°, 90°, 180°" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Radianes: [0. 0.52359878 0.78539816 1.04719755 1.57079633 3.14159265]\n", + "Senos: [0.00000000e+00 5.00000000e-01 7.07106781e-01 8.66025404e-01\n", + " 1.00000000e+00 1.22464680e-16]\n" + ] + } + ], + "source": [ + "grados = np.array([0, 30, 45, 60, 90, 180])\n", + "\n", + "radianes = grados * np.pi / 180\n", + "senos = np.sin(radianes)\n", + "\n", + "print(\"Radianes:\", radianes)\n", + "print(\"Senos:\", senos)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Ejercicio 3 — Filtrado y estadísticas\n", + "\n", + "Dada la lista de temperaturas diarias de un mes, calcula:\n", + "1. La temperatura promedio, mínima y máxima\n", + "2. Cuántos días superaron los 28°C\n", + "3. Las temperaturas de los días fríos (menores a 20°C)\n", + "4. Reemplaza con `np.where` las temperaturas menores a 15°C por exactamente 15.0 (temperatura mínima registrada)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Promedio: 23.483333333333334\n", + "Mínima: 12.4\n", + "Máxima: 33.1\n", + "Días > 28°C: 8\n", + "Temperaturas < 20°C: [19.5 17.3 14.2 18.9 16.8 13.5 15.7 19. 18.1 12.4]\n", + "Temperaturas corregidas: [22.1 19.5 31.2 28. 17.3 25.8 30.1 15. 26.7 23.4 18.9 32. 29.5 21.1\n", + " 16.8 27.3 24.6 15. 20. 28.9 33.1 15.7 22.8 19. 31.5 26.2 18.1 29.8\n", + " 15. 25. ]\n" + ] + } + ], + "source": [ + "temperaturas = np.array([\n", + " 22.1, 19.5, 31.2, 28.0, 17.3, 25.8, 30.1,\n", + " 14.2, 26.7, 23.4, 18.9, 32.0, 29.5, 21.1,\n", + " 16.8, 27.3, 24.6, 13.5, 20.0, 28.9, 33.1,\n", + " 15.7, 22.8, 19.0, 31.5, 26.2, 18.1, 29.8,\n", + " 12.4, 25.0\n", + "])\n", + "\n", + "# Promedio, mínimo y máximo\n", + "promedio = np.mean(temperaturas)\n", + "min_temp = np.min(temperaturas)\n", + "max_temp = np.max(temperaturas)\n", + "\n", + "print(\"Promedio:\", promedio)\n", + "print(\"Mínima:\", min_temp)\n", + "print(\"Máxima:\", max_temp)\n", + "\n", + "\n", + "# Días que superaron los 28°C\n", + "dias_mayores_28 = np.sum(temperaturas > 28)\n", + "print(\"Días > 28°C:\", dias_mayores_28)\n", + "\n", + "\n", + "# Temperaturas de días fríos (<20°C)\n", + "dias_frios = temperaturas[temperaturas < 20]\n", + "print(\"Temperaturas < 20°C:\", dias_frios)\n", + "\n", + "\n", + "# Reemplazo de temperaturas menores a 15°C por 15.0\n", + "temperaturas_corregidas = np.where(temperaturas < 15, 15.0, temperaturas)\n", + "print(\"Temperaturas corregidas:\", temperaturas_corregidas)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Ejercicio 4 — Matrices\n", + "\n", + "Crea una matriz de 4×4 con valores del 1 al 16 usando `np.arange` y `reshape`. \n", + "Luego:\n", + "1. Imprime la primera fila\n", + "2. Imprime la última columna\n", + "3. Imprime la submatriz de las 2 primeras filas y las 2 últimas columnas\n", + "4. Calcula la suma de cada fila (investiga `np.sum` con el parámetro `axis`)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Primera fila: [1 2 3 4]\n", + "Última columna: [ 4 8 12 16]\n", + "Submatriz:\n", + " [[3 4]\n", + " [7 8]]\n", + "Suma por filas: [10 26 42 58]\n" + ] + } + ], + "source": [ + "matriz = np.arange(1, 17).reshape(4, 4)\n", + "\n", + "print(\"Primera fila:\", matriz[0])\n", + "print(\"Última columna:\", matriz[:, -1])\n", + "\n", + "print(\"Submatriz:\\n\", matriz[0:2, 2:4])\n", + "\n", + "print(\"Suma por filas:\", np.sum(matriz, axis=1))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Ejercicio 5 — Suma acumulativa\n", + "\n", + "Un estudiante anotó los puntos que obtuvo en cada una de las 8 tareas del curso. \n", + "Calcula e imprime los puntos acumulados después de cada tarea para saber en qué momento superó 100, 200 y 300 puntos.\n", + "\n", + "**Tip:** usa `np.cumsum` y filtra con indexación booleana." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Acumulado: [ 45 83 135 164 225 272 327 360]\n", + ">100: [135 164 225 272 327 360]\n", + ">200: [225 272 327 360]\n", + ">300: [327 360]\n" + ] + } + ], + "source": [ + "puntos_tareas = np.array([45, 38, 52, 29, 61, 47, 55, 33])\n", + "\n", + "acum = np.cumsum(puntos_tareas)\n", + "print(\"Acumulado:\", acum)\n", + "\n", + "print(\">100:\", acum[acum > 100])\n", + "print(\">200:\", acum[acum > 200])\n", + "print(\">300:\", acum[acum > 300])\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Ejercicio 6 — Álgebra Lineal\n", + "\n", + "El sistema de ecuaciones representa un balance de fuerzas en una estructura:\n", + "\n", + "$$2F_1 + F_2 = 100$$\n", + "$$F_1 + 3F_2 + F_3 = 200$$\n", + "$$F_2 + 2F_3 = 150$$\n", + "\n", + "Usando `numpy.linalg`:\n", + "1. Resuelve el sistema con `la.solve(A, b)` para encontrar $F_1$, $F_2$, $F_3$\n", + "2. Verifica la solución calculando `A @ x - b` (debe ser ≈ 0)\n", + "3. Calcula el determinante de A con `la.det(A)`\n", + "4. Calcula la norma de la solución `x` con `la.norm(x)`" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solución: [31.25 37.5 56.25]\n", + "A @ x - b: [0. 0. 0.]\n", + "Determinante: 8.000000000000002\n", + "Norma: 74.47734554883115\n" + ] + } + ], + "source": [ + "import numpy.linalg as la\n", + "\n", + "# Sistema de ecuaciones (balance de fuerzas en un puente):\n", + "# 2F1 + F2 = 100\n", + "# F1 + 3F2 + F3 = 200\n", + "# F2 + 2F3 = 150\n", + "\n", + "A = np.array([[2, 1, 0],\n", + " [1, 3, 1],\n", + " [0, 1, 2]], dtype=float)\n", + "b = np.array([100, 200, 150], dtype=float)\n", + "\n", + "x = la.solve(A, b)\n", + "\n", + "print(\"Solución:\", x)\n", + "\n", + "# Verificación\n", + "print(\"A @ x - b:\", A @ x - b)\n", + "\n", + "# Determinante\n", + "print(\"Determinante:\", la.det(A))\n", + "\n", + "# Norma\n", + "print(\"Norma:\", la.norm(x))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Ejercicio 7 — Polinomios (ajuste de curva)\n", + "\n", + "Un objeto en caída libre sigue la ecuación $x(t) = \\frac{1}{2}g t^2$.\n", + "\n", + "Con los datos de tiempo y posición dados, usa `np.polyfit` para ajustar un polinomio de grado 2 y:\n", + "1. Muestra los coeficientes obtenidos\n", + "2. Estima la aceleración de gravedad `g` a partir del coeficiente cuadrático\n", + "3. Usa `np.polyval` para predecir la posición en `t = 2.5` s y `t = 6` s\n", + "\n", + "**Pista:** el coeficiente de $t^2$ en el polinomio es $\\frac{g}{2}$." + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Coeficientes: [ 4.90000000e+00 -1.24470554e-14 2.49582512e-14]\n", + "Gravedad estimada: 9.800000000000013\n", + "t=2.5: 30.625000000000032\n", + "t=6: 176.40000000000018\n" + ] + } + ], + "source": [ + "t = np.array([0, 1, 2, 3, 4, 5], dtype=float) # tiempo (s)\n", + "pos = np.array([0.0, 4.9, 19.6, 44.1, 78.4, 122.5]) # posición (m)\n", + "\n", + "coef = np.polyfit(t, pos, 2)\n", + "print(\"Coeficientes:\", coef)\n", + "\n", + "g = 2 * coef[0]\n", + "print(\"Gravedad estimada:\", g)\n", + "\n", + "print(\"t=2.5:\", np.polyval(coef, 2.5))\n", + "print(\"t=6:\", np.polyval(coef, 6))\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.7" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/tarea/Tarea_4_y_5/Pandas.ipynb b/tarea/Tarea_4_y_5/Pandas.ipynb new file mode 100644 index 0000000..9f53a11 --- /dev/null +++ b/tarea/Tarea_4_y_5/Pandas.ipynb @@ -0,0 +1,1997 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Pandas — Análisis y Manipulación de Datos\n", + "\n", + "## ¿Qué es Pandas?\n", + "\n", + "**Pandas** es la librería más utilizada para análisis y manipulación de datos en Python. Su nombre viene de **Pan**el **Da**ta (datos de panel), un término de econometría.\n", + "\n", + "Pandas introduce dos estructuras de datos fundamentales:\n", + "\n", + "| Estructura | Descripción | Analogía |\n", + "|---|---|---|\n", + "| **Series** | Arreglo unidimensional con etiquetas | Una columna de Excel |\n", + "| **DataFrame** | Tabla bidimensional con filas y columnas | Una hoja de Excel |\n", + "\n", + "## ¿Para qué sirve?\n", + "\n", + "- Leer y escribir datos (CSV, Excel, SQL, JSON, etc.)\n", + "- Limpiar datos (manejar valores nulos, duplicados, errores)\n", + "- Filtrar, ordenar y agrupar datos\n", + "- Calcular estadísticas y resúmenes\n", + "- Preparar datos para visualización o machine learning" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Instalación e Importación\n", + "\n", + "```bash\n", + "pip install pandas\n", + "```\n", + "\n", + "Por convención, se importa con el alias `pd`:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pandas versión: 2.3.3\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "import numpy as np # Pandas y NumPy se usan frecuentemente juntos\n", + "\n", + "print(\"Pandas versión:\", pd.__version__)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## Nivel 1 — Series" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Serie de temperaturas:\n", + "0 25.1\n", + "1 27.3\n", + "2 24.8\n", + "3 28.5\n", + "4 26.0\n", + "dtype: float64\n", + "\n", + "Tipo: \n" + ] + } + ], + "source": [ + "# Crear una Serie desde una lista\n", + "temperaturas = pd.Series([25.1, 27.3, 24.8, 28.5, 26.0])\n", + "print(\"Serie de temperaturas:\")\n", + "print(temperaturas)\n", + "print(\"\\nTipo:\", type(temperaturas))" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Temperatura por día:\n", + "Lunes 25.1\n", + "Martes 27.3\n", + "Miércoles 24.8\n", + "Jueves 28.5\n", + "Viernes 26.0\n", + "dtype: float64\n", + "\n", + "Temperatura del Martes: 27.3\n", + "Promedio de la semana: 26.339999999999996\n" + ] + } + ], + "source": [ + "# Serie con índices personalizados (etiquetas)\n", + "dias = pd.Series(\n", + " [25.1, 27.3, 24.8, 28.5, 26.0],\n", + " index=[\"Lunes\", \"Martes\", \"Miércoles\", \"Jueves\", \"Viernes\"]\n", + ")\n", + "print(\"Temperatura por día:\")\n", + "print(dias)\n", + "\n", + "print(\"\\nTemperatura del Martes:\", dias[\"Martes\"])\n", + "print(\"Promedio de la semana:\", dias.mean())" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mean: 8.258333333333333\n", + "min: -0.3\n", + "standard deviation: 6.520242373260415\n", + "index of max element: 6\n", + "values as list: [-0.3 0.4 3.9 7.4 12. 15. 17.2 16.8 13.1 9.1 3.7 0.8]\n", + "indices of sorted Series: [ 0 1 11 10 2 3 9 4 8 5 7 6]\n", + "cumulative sum: [-0.3 0.1 4. 11.4 23.4 38.4 55.6 72.4 85.5 94.6 98.3 99.1]\n" + ] + } + ], + "source": [ + "# Métodos estadísticos de una Serie (§8.1)\n", + "s = pd.Series([-0.3, 0.4, 3.9, 7.4, 12.0, 15.0, 17.2,\n", + " 16.8, 13.1, 9.1, 3.7, 0.8], name='temp_C')\n", + "\n", + "print('mean:', s.mean())\n", + "print('min:', s.min())\n", + "print('standard deviation:', s.std())\n", + "print('index of max element:', s.argmax())\n", + "print('values as list:', s.values)\n", + "print('indices of sorted Series:', s.argsort().values)\n", + "print('cumulative sum:', s.cumsum().values)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "jan -0.3\n", + "feb 0.4\n", + "mar 3.9\n", + "apr 7.4\n", + "may 12.0\n", + "jun 15.0\n", + "jul 17.2\n", + "aug 16.8\n", + "sep 13.1\n", + "oct 9.1\n", + "nov 3.7\n", + "dec 0.8\n", + "Name: temp_C, dtype: float64\n", + "\n", + "Temperatura en octubre: 9.1\n" + ] + } + ], + "source": [ + "# Índice con etiquetas — set_axis() (§8.1)\n", + "s2 = s.set_axis(['jan', 'feb', 'mar', 'apr', 'may', 'jun',\n", + " 'jul', 'aug', 'sep', 'oct', 'nov', 'dec'])\n", + "print(s2)\n", + "print(\"\\nTemperatura en octubre:\", s2['oct'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## Nivel 2 — DataFrames" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Crear un DataFrame" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Nombre Edad Carrera Promedio\n", + "0 Ana 20 Física 85.5\n", + "1 Carlos 22 Matemática 72.0\n", + "2 Diana 21 Física 91.3\n", + "3 Eduardo 23 Computación 68.7\n", + "4 Fátima 20 Matemática 79.2\n" + ] + } + ], + "source": [ + "# Crear DataFrame desde un diccionario\n", + "datos = {\n", + " \"Nombre\": [\"Ana\", \"Carlos\", \"Diana\", \"Eduardo\", \"Fátima\"],\n", + " \"Edad\": [20, 22, 21, 23, 20],\n", + " \"Carrera\": [\"Física\", \"Matemática\", \"Física\", \"Computación\", \"Matemática\"],\n", + " \"Promedio\": [85.5, 72.0, 91.3, 68.7, 79.2]\n", + "}\n", + "\n", + "df = pd.DataFrame(datos)\n", + "print(df)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Forma (filas x columnas): (5, 4)\n", + "\n", + "Nombres de columnas: ['Nombre', 'Edad', 'Carrera', 'Promedio']\n", + "\n", + "Tipos de datos:\n", + "Nombre object\n", + "Edad int64\n", + "Carrera object\n", + "Promedio float64\n", + "dtype: object\n" + ] + } + ], + "source": [ + "# Información básica del DataFrame\n", + "print(\"Forma (filas x columnas):\", df.shape)\n", + "print(\"\\nNombres de columnas:\", df.columns.tolist())\n", + "print(\"\\nTipos de datos:\")\n", + "print(df.dtypes)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Estadísticas descriptivas:\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
EdadPromedio
count5.000005.000000
mean21.2000079.340000
std1.303849.328612
min20.0000068.700000
25%20.0000072.000000
50%21.0000079.200000
75%22.0000085.500000
max23.0000091.300000
\n", + "
" + ], + "text/plain": [ + " Edad Promedio\n", + "count 5.00000 5.000000\n", + "mean 21.20000 79.340000\n", + "std 1.30384 9.328612\n", + "min 20.00000 68.700000\n", + "25% 20.00000 72.000000\n", + "50% 21.00000 79.200000\n", + "75% 22.00000 85.500000\n", + "max 23.00000 91.300000" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Resumen estadístico automático\n", + "print(\"Estadísticas descriptivas:\")\n", + "df.describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Primeras 3 filas:\n", + " temp_C rain_mm\n", + "jan -0.3 59\n", + "feb 0.4 57\n", + "mar 3.9 84\n", + "\n", + "Últimas 2 filas:\n", + " temp_C rain_mm\n", + "nov 3.7 88\n", + "dec 0.8 80\n", + "\n", + "Columnas: ['temp_C', 'rain_mm']\n", + "Índice (list): ['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec']\n" + ] + } + ], + "source": [ + "# head(), tail() y atributos del índice (§8.2.1)\n", + "df_clima = pd.DataFrame({\n", + " 'temp_C': [-0.3, 0.4, 3.9, 7.4, 12.0, 15.0,\n", + " 17.2, 16.8, 13.1, 9.1, 3.7, 0.8],\n", + " 'rain_mm': [59, 57, 84, 100, 143, 153, 172, 164, 135, 89, 88, 80]\n", + "}, index=['jan','feb','mar','apr','may','jun',\n", + " 'jul','aug','sep','oct','nov','dec'])\n", + "\n", + "print(\"Primeras 3 filas:\")\n", + "print(df_clima.head(3))\n", + "print(\"\\nÚltimas 2 filas:\")\n", + "print(df_clima.tail(2))\n", + "print(\"\\nColumnas:\", df_clima.columns.tolist())\n", + "print(\"Índice (list):\", list(df_clima.index))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Acceder a datos" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Columna 'Nombre':\n", + "0 Ana\n", + "1 Carlos\n", + "2 Diana\n", + "3 Eduardo\n", + "4 Fátima\n", + "Name: Nombre, dtype: object\n", + "\n", + "Columnas 'Nombre' y 'Promedio':\n", + " Nombre Promedio\n", + "0 Ana 85.5\n", + "1 Carlos 72.0\n", + "2 Diana 91.3\n", + "3 Eduardo 68.7\n", + "4 Fátima 79.2\n" + ] + } + ], + "source": [ + "# Acceder a una columna\n", + "print(\"Columna 'Nombre':\")\n", + "print(df[\"Nombre\"])\n", + "\n", + "print(\"\\nColumnas 'Nombre' y 'Promedio':\")\n", + "print(df[[\"Nombre\", \"Promedio\"]])" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Primera fila (iloc[0]):\n", + "Nombre Ana\n", + "Edad 20\n", + "Carrera Física\n", + "Promedio 85.5\n", + "Name: 0, dtype: object\n", + "\n", + "Filas 1 a 3 (iloc[1:4]):\n", + " Nombre Edad Carrera Promedio\n", + "1 Carlos 22 Matemática 72.0\n", + "2 Diana 21 Física 91.3\n", + "3 Eduardo 23 Computación 68.7\n" + ] + } + ], + "source": [ + "# Acceder a filas con .iloc (por posición numérica)\n", + "print(\"Primera fila (iloc[0]):\")\n", + "print(df.iloc[0])\n", + "\n", + "print(\"\\nFilas 1 a 3 (iloc[1:4]):\")\n", + "print(df.iloc[1:4])" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fila con índice 2:\n", + "Nombre Diana\n", + "Edad 21\n", + "Carrera Física\n", + "Promedio 91.3\n", + "Name: 2, dtype: object\n", + "\n", + "Valor en fila 0, columna 'Nombre': Ana\n" + ] + } + ], + "source": [ + "# Acceder a filas con .loc (por etiqueta/índice)\n", + "print(\"Fila con índice 2:\")\n", + "print(df.loc[2])\n", + "\n", + "# Acceder a un valor específico: fila 0, columna 'Nombre'\n", + "print(\"\\nValor en fila 0, columna 'Nombre':\", df.loc[0, \"Nombre\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### `loc` avanzado — selección por etiqueta (§8.2.2)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Marzo, abril y junio:\n", + " temp_C rain_mm\n", + "mar 3.9 84\n", + "apr 7.4 100\n", + "jun 15.0 153\n" + ] + } + ], + "source": [ + "# loc con lista de etiquetas (§8.2.2)\n", + "print(\"Marzo, abril y junio:\")\n", + "print(df_clima.loc[['mar', 'apr', 'jun']])" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "De marzo a mayo:\n", + " temp_C rain_mm\n", + "mar 3.9 84\n", + "apr 7.4 100\n", + "may 12.0 143\n" + ] + } + ], + "source": [ + "# loc con slice de etiquetas — el extremo final SÍ se incluye (§8.2.2)\n", + "print(\"De marzo a mayo:\")\n", + "print(df_clima.loc['mar':'may'])" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Lluvia de mayo a septiembre:\n", + "may 143\n", + "jun 153\n", + "jul 172\n", + "aug 164\n", + "sep 135\n", + "Name: rain_mm, dtype: int64\n", + "\n", + "Total de lluvia en verano: 767\n" + ] + } + ], + "source": [ + "# loc combinando filas Y columnas: df.loc[, ] (§8.2.2)\n", + "print(\"Lluvia de mayo a septiembre:\")\n", + "print(df_clima.loc['may':'sep', 'rain_mm'])\n", + "\n", + "print(\"\\nTotal de lluvia en verano:\", df_clima.loc['may':'sep', 'rain_mm'].sum())" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Temp en meses con lluvia < 100 mm:\n", + "jan -0.3\n", + "feb 0.4\n", + "mar 3.9\n", + "oct 9.1\n", + "nov 3.7\n", + "dec 0.8\n", + "Name: temp_C, dtype: float64\n" + ] + } + ], + "source": [ + "# Máscara booleana con loc (§8.2.2)\n", + "# Temperatura en meses con lluvia < 100 mm\n", + "print(\"Temp en meses con lluvia < 100 mm:\")\n", + "print(df_clima.loc[df_clima['rain_mm'] < 100, 'temp_C'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## Nivel 3 — Filtrado, Ordenamiento y Nuevas Columnas" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Filtrar filas con condiciones" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Estudiantes con promedio > 75:\n", + " Nombre Edad Carrera Promedio\n", + "0 Ana 20 Física 85.5\n", + "2 Diana 21 Física 91.3\n", + "4 Fátima 20 Matemática 79.2\n", + "\n", + "Estudiantes de Física:\n", + " Nombre Edad Carrera Promedio\n", + "0 Ana 20 Física 85.5\n", + "2 Diana 21 Física 91.3\n" + ] + } + ], + "source": [ + "# Estudiantes con promedio mayor a 75\n", + "buenos = df[df[\"Promedio\"] > 75]\n", + "print(\"Estudiantes con promedio > 75:\")\n", + "print(buenos)\n", + "\n", + "print()\n", + "\n", + "# Estudiantes de Física\n", + "fisica = df[df[\"Carrera\"] == \"Física\"]\n", + "print(\"Estudiantes de Física:\")\n", + "print(fisica)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Promedio > 70 Y Edad <= 21:\n", + " Nombre Edad Carrera Promedio\n", + "0 Ana 20 Física 85.5\n", + "2 Diana 21 Física 91.3\n", + "4 Fátima 20 Matemática 79.2\n" + ] + } + ], + "source": [ + "# Condiciones múltiples\n", + "# & = AND, | = OR\n", + "filtro = df[(df[\"Promedio\"] > 70) & (df[\"Edad\"] <= 21)]\n", + "print(\"Promedio > 70 Y Edad <= 21:\")\n", + "print(filtro)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Ordenar datos" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ranking por promedio:\n", + " Nombre Promedio\n", + "2 Diana 91.3\n", + "0 Ana 85.5\n", + "4 Fátima 79.2\n", + "1 Carlos 72.0\n", + "3 Eduardo 68.7\n" + ] + } + ], + "source": [ + "# Ordenar por promedio (descendente)\n", + "ranking = df.sort_values(\"Promedio\", ascending=False)\n", + "print(\"Ranking por promedio:\")\n", + "print(ranking[[\"Nombre\", \"Promedio\"]])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Agregar nuevas columnas" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Nombre Edad Carrera Promedio Estado Puntos_extra\n", + "0 Ana 20 Física 85.5 Aprobado 15.5\n", + "1 Carlos 22 Matemática 72.0 Aprobado 2.0\n", + "2 Diana 21 Física 91.3 Aprobado 21.3\n", + "3 Eduardo 23 Computación 68.7 Reprobado 0.0\n", + "4 Fátima 20 Matemática 79.2 Aprobado 9.2\n" + ] + } + ], + "source": [ + "# Agregar columna calculada\n", + "df[\"Estado\"] = df[\"Promedio\"].apply(lambda p: \"Aprobado\" if p >= 70 else \"Reprobado\")\n", + "df[\"Puntos_extra\"] = (df[\"Promedio\"] - 70).clip(lower=0).round(1)\n", + "\n", + "print(df)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Modificar datos y combinar DataFrames (§8.2.3)\n", + "\n", + "`df.assign()` crea columnas nuevas de forma funcional sin modificar el original." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " temp_C rain_mm temp_F\n", + "jan -0.3 59 31.46\n", + "feb 0.4 57 32.72\n", + "mar 3.9 84 39.02\n", + "apr 7.4 100 45.32\n", + "may 12.0 143 53.60\n" + ] + } + ], + "source": [ + "# assign() — agregar columna con función (§8.2.3)\n", + "def celsius_a_f(df):\n", + " return df['temp_C'] * 1.8 + 32\n", + "\n", + "df_clima_f = df_clima.assign(temp_F=celsius_a_f)\n", + "print(df_clima_f.head())" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " temp_C rain_mm\n", + "jan -0.3 59.0\n", + "feb 0.4 57.0\n", + "mar 3.9 84.0\n", + "apr 7.4 100.0\n", + "may 12.0 143.0\n", + "jun 15.0 153.0\n", + "jul 17.2 172.0\n", + "aug 16.8 164.0\n", + "sep 13.1 135.0\n", + "oct 9.1 89.0\n", + "nov 3.7 88.0\n", + "dec 0.8 80.0\n", + "2020 9.7 165.8\n", + "2019 9.5 146.1\n", + "2018 9.9 139.2\n" + ] + } + ], + "source": [ + "# pd.concat() — combinar filas (§8.2.3)\n", + "df_anual = pd.DataFrame({\n", + " 'temp_C': [9.7, 9.5, 9.9],\n", + " 'rain_mm': [165.8, 146.1, 139.2]\n", + "}, index=['2020', '2019', '2018'])\n", + "\n", + "df_ext = pd.concat([df_clima, df_anual])\n", + "print(df_ext)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " temp_C rain_mm temp_min_C temp_max_C\n", + "jan -0.3 59 -1.9 2.5\n", + "feb 0.4 57 -2.5 3.3\n", + "mar 3.9 84 0.6 7.3\n", + "apr 7.4 100 3.5 11.5\n", + "may 12.0 143 7.8 16.3\n", + "jun 15.0 153 11.0 19.2\n", + "jul 17.2 172 13.1 21.6\n", + "aug 16.8 164 13.0 20.9\n", + "sep 13.1 135 9.7 16.8\n", + "oct 9.1 89 6.2 12.3\n", + "nov 3.7 88 1.0 6.5\n", + "dec 0.8 80 -3.0 3.5\n" + ] + } + ], + "source": [ + "# pd.concat() con axis=1 — combinar columnas (§8.2.3)\n", + "df_minmax = pd.DataFrame({\n", + " 'temp_min_C': [-1.9, -2.5, 0.6, 3.5, 7.8, 11.0,\n", + " 13.1, 13.0, 9.7, 6.2, 1.0, -3.0],\n", + " 'temp_max_C': [2.5, 3.3, 7.3, 11.5, 16.3, 19.2,\n", + " 21.6, 20.9, 16.8, 12.3, 6.5, 3.5]\n", + "}, index=df_clima.index)\n", + "\n", + "df_completo = pd.concat([df_clima, df_minmax], axis=1)\n", + "print(df_completo)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## Nivel 4 — Agrupaciones y Agregaciones" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Estadísticas por carrera:\n", + " Promedio_medio Mínimo Máximo Estudiantes\n", + "Carrera \n", + "Computación 68.7 68.7 68.7 1\n", + "Física 88.4 85.5 91.3 2\n", + "Matemática 75.6 72.0 79.2 2\n" + ] + } + ], + "source": [ + "# groupby: agrupar por una columna y calcular estadísticas\n", + "por_carrera = df.groupby(\"Carrera\")[\"Promedio\"].agg([\"mean\", \"min\", \"max\", \"count\"])\n", + "por_carrera.columns = [\"Promedio_medio\", \"Mínimo\", \"Máximo\", \"Estudiantes\"]\n", + "\n", + "print(\"Estadísticas por carrera:\")\n", + "print(por_carrera.round(2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## Nivel 5 — Manejo de Datos Faltantes" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataFrame con valores faltantes:\n", + " Nombre Nota1 Nota2 Nota3\n", + "0 Ana 85.0 78.0 92.0\n", + "1 Carlos NaN 65.0 71.0\n", + "2 Diana 90.0 NaN 85.0\n", + "3 Eduardo 72.0 80.0 NaN\n", + "4 Fátima NaN 88.0 76.0\n", + "\n", + "Cantidad de nulos por columna:\n", + "Nombre 0\n", + "Nota1 2\n", + "Nota2 1\n", + "Nota3 1\n", + "dtype: int64\n" + ] + } + ], + "source": [ + "# Crear DataFrame con datos faltantes (NaN = Not a Number)\n", + "datos_incompletos = pd.DataFrame({\n", + " \"Nombre\": [\"Ana\", \"Carlos\", \"Diana\", \"Eduardo\", \"Fátima\"],\n", + " \"Nota1\": [85, np.nan, 90, 72, np.nan],\n", + " \"Nota2\": [78, 65, np.nan, 80, 88],\n", + " \"Nota3\": [92, 71, 85, np.nan, 76]\n", + "})\n", + "\n", + "print(\"DataFrame con valores faltantes:\")\n", + "print(datos_incompletos)\n", + "print(\"\\nCantidad de nulos por columna:\")\n", + "print(datos_incompletos.isnull().sum())" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Después de rellenar con la media:\n", + " Nombre Nota1 Nota2 Nota3\n", + "0 Ana 85.0 78.0 92.0\n", + "1 Carlos 82.3 65.0 71.0\n", + "2 Diana 90.0 77.8 85.0\n", + "3 Eduardo 72.0 80.0 81.0\n", + "4 Fátima 82.3 88.0 76.0\n" + ] + } + ], + "source": [ + "# Opción 1: Rellenar con la media de la columna\n", + "df_rellenado = datos_incompletos.copy()\n", + "for col in [\"Nota1\", \"Nota2\", \"Nota3\"]:\n", + " df_rellenado[col] = df_rellenado[col].fillna(df_rellenado[col].mean())\n", + "\n", + "print(\"Después de rellenar con la media:\")\n", + "print(df_rellenado.round(1))" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Después de eliminar filas con nulos:\n", + " Nombre Nota1 Nota2 Nota3\n", + "0 Ana 85.0 78.0 92.0\n" + ] + } + ], + "source": [ + "# Opción 2: Eliminar filas con datos faltantes\n", + "df_limpio = datos_incompletos.dropna()\n", + "print(\"Después de eliminar filas con nulos:\")\n", + "print(df_limpio)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### `isna()`, `fillna()` e `interpolate()` (§8.2.4)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mapa de NaN:\n", + " Nombre Nota1 Nota2 Nota3\n", + "0 False False False False\n", + "1 False True False False\n", + "2 False False True False\n", + "3 False False False True\n", + "4 False True False False\n", + "\n", + "Total de NaN por columna:\n", + "Nombre 0\n", + "Nota1 2\n", + "Nota2 1\n", + "Nota3 1\n", + "dtype: int64\n" + ] + } + ], + "source": [ + "# isna() / notna() — mapa de valores faltantes (§8.2.4)\n", + "print(\"Mapa de NaN:\")\n", + "print(datos_incompletos.isna())\n", + "\n", + "print(\"\\nTotal de NaN por columna:\")\n", + "print(datos_incompletos.isna().sum())" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Rellenado con la media de cada columna:\n", + " Nombre Nota1 Nota2 Nota3\n", + "0 Ana 85.0 78.0 92.0\n", + "1 Carlos 82.3 65.0 71.0\n", + "2 Diana 90.0 77.8 85.0\n", + "3 Eduardo 72.0 80.0 81.0\n", + "4 Fátima 82.3 88.0 76.0\n" + ] + } + ], + "source": [ + "# fillna con la media de cada columna (§8.2.4)\n", + "df_relleno2 = datos_incompletos.copy()\n", + "df_relleno2 = df_relleno2.fillna(\n", + " df_relleno2.mean(axis=0, numeric_only=True)\n", + ")\n", + "print(\"Rellenado con la media de cada columna:\")\n", + "print(df_relleno2.round(1))" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Original: [ 1. nan 3. nan 5.]\n", + "Interpolado: [1. 2. 3. 4. 5.]\n" + ] + } + ], + "source": [ + "# interpolate() — interpolación lineal (§8.2.4)\n", + "s_nan = pd.Series([1.0, np.nan, 3.0, np.nan, 5.0])\n", + "print(\"Original:\", s_nan.values)\n", + "print(\"Interpolado:\", s_nan.interpolate().values)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## Nivel 6 — Leer Datos desde Archivos\n", + "\n", + "En la práctica, los datos vienen de archivos externos. Pandas puede leer muchos formatos:" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "ename": "FileNotFoundError", + "evalue": "[Errno 2] No such file or directory: '/tmp/estudiantes.csv'", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mFileNotFoundError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[31]\u001b[39m\u001b[32m, line 10\u001b[39m\n\u001b[32m 6\u001b[39m Eduardo,\u001b[32m23\u001b[39m,Computación,\u001b[32m68\u001b[39m\n\u001b[32m 7\u001b[39m Fátima,\u001b[32m20\u001b[39m,Matemática,\u001b[32m79\u001b[39m\n\u001b[32m 8\u001b[39m \"\"\"\n\u001b[32m 9\u001b[39m \n\u001b[32m---> \u001b[39m\u001b[32m10\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m open(\u001b[33m\"/tmp/estudiantes.csv\"\u001b[39m, \u001b[33m\"w\"\u001b[39m) \u001b[38;5;28;01mas\u001b[39;00m f:\n\u001b[32m 11\u001b[39m f.write(csv_contenido)\n\u001b[32m 12\u001b[39m \n\u001b[32m 13\u001b[39m \u001b[38;5;66;03m# Leer el CSV\u001b[39;00m\n", + "\u001b[31mFileNotFoundError\u001b[39m: [Errno 2] No such file or directory: '/tmp/estudiantes.csv'" + ] + } + ], + "source": [ + "# Crear un CSV de ejemplo para practicar\n", + "csv_contenido = \"\"\"nombre,edad,carrera,nota\n", + "Ana,20,Física,85\n", + "Carlos,22,Matemática,72\n", + "Diana,21,Física,91\n", + "Eduardo,23,Computación,68\n", + "Fátima,20,Matemática,79\n", + "\"\"\"\n", + "\n", + "with open(\"/tmp/estudiantes.csv\", \"w\") as f:\n", + " f.write(csv_contenido)\n", + "\n", + "# Leer el CSV\n", + "df_csv = pd.read_csv(\"/tmp/estudiantes.csv\")\n", + "print(\"Datos leídos desde CSV:\")\n", + "print(df_csv)\n", + "print(\"\\nPrimeras 3 filas (head):\")\n", + "print(df_csv.head(3))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Guardar un DataFrame como CSV\n", + "df_csv.to_csv(\"/tmp/resultado.csv\", index=False)\n", + "print(\"Archivo guardado como /tmp/resultado.csv\")\n", + "\n", + "# Otros formatos comunes:\n", + "# df.to_excel(\"archivo.xlsx\", index=False)\n", + "# df = pd.read_excel(\"archivo.xlsx\")\n", + "# df = pd.read_json(\"archivo.json\")" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " temp_C uv nubes\n", + "dia \n", + "lunes 12.3 5 clear\n", + "martes 13.5 4 clear\n", + "miercoles 9.2 1 mostly cloudy\n", + "jueves 8.2 2 partly cloudy\n", + "viernes 10.2 3 partly cloudy\n" + ] + } + ], + "source": [ + "# read_csv con opciones avanzadas (§8.6)\n", + "import io\n", + "\n", + "csv_sin_header = \"\"\"lunes,12.3,5,clear\n", + "martes,13.5,4,clear\n", + "miercoles,9.2,1,mostly cloudy\n", + "jueves,8.2,2,partly cloudy\n", + "viernes,10.2,3,partly cloudy\n", + "\"\"\"\n", + "\n", + "df_weather = pd.read_csv(\n", + " io.StringIO(csv_sin_header),\n", + " names=['dia', 'temp_C', 'uv', 'nubes'],\n", + " index_col='dia'\n", + ")\n", + "print(df_weather)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## Nivel 7 — Datos Categóricos (§8.3.1)\n", + "\n", + "Los datos categóricos toman valores de un conjunto discreto y finito de categorías." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " nubes uv\n", + "lun nublado 0\n", + "mar nublado 0\n", + "mié parcialmente nublado 1\n", + "jue mayormente despejado 3\n", + "vie despejado 5\n", + "sáb despejado 5\n", + "dom parcialmente nublado 1\n" + ] + } + ], + "source": [ + "# DataFrame con datos categóricos\n", + "df_cat = pd.DataFrame({\n", + " 'nubes': ['nublado', 'nublado', 'parcialmente nublado',\n", + " 'mayormente despejado', 'despejado', 'despejado', 'parcialmente nublado'],\n", + " 'uv': [0, 0, 1, 3, 5, 5, 1]\n", + "}, index=['lun', 'mar', 'mié', 'jue', 'vie', 'sáb', 'dom'])\n", + "\n", + "print(df_cat)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Categorías únicas:\n", + "['nublado' 'parcialmente nublado' 'mayormente despejado' 'despejado']\n", + "\n", + "Frecuencia de cada categoría:\n", + "nubes\n", + "nublado 2\n", + "parcialmente nublado 2\n", + "despejado 2\n", + "mayormente despejado 1\n", + "Name: count, dtype: int64\n" + ] + } + ], + "source": [ + "# unique() — valores únicos | value_counts() — frecuencia (§8.3.1)\n", + "print(\"Categorías únicas:\")\n", + "print(df_cat['nubes'].unique())\n", + "\n", + "print(\"\\nFrecuencia de cada categoría:\")\n", + "print(df_cat['nubes'].value_counts())" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "UV promedio en días parcialmente nublados: 1.0\n" + ] + } + ], + "source": [ + "# Filtrar por categoría y aplicar método (§8.3.1)\n", + "uv_parcial = df_cat.loc[df_cat['nubes'] == 'parcialmente nublado', 'uv'].mean()\n", + "print(\"UV promedio en días parcialmente nublados:\", uv_parcial)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## Nivel 8 — Datos de Texto: `pd.Series.str` (§8.3.2)\n", + "\n", + "Pandas provee funciones vectorizadas para strings a través del submódulo `str`." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "¿Contiene 'nublado'?\n", + "lun True\n", + "mar True\n", + "mié True\n", + "jue False\n", + "vie False\n", + "sáb False\n", + "dom True\n", + "Name: nubes, dtype: bool\n", + "\n", + "Filas con nubosidad:\n", + " nubes uv\n", + "lun nublado 0\n", + "mar nublado 0\n", + "mié parcialmente nublado 1\n", + "dom parcialmente nublado 1\n" + ] + } + ], + "source": [ + "# str.contains() — filtrar filas que contienen una subcadena (§8.3.2)\n", + "mascara = df_cat['nubes'].str.contains('nublado', regex=False)\n", + "print(\"¿Contiene 'nublado'?\")\n", + "print(mascara)\n", + "\n", + "print(\"\\nFilas con nubosidad:\")\n", + "print(df_cat.loc[mascara])" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " nubes uv\n", + "lun soleado 0\n", + "mar soleado 0\n", + "mié parcialmente soleado 1\n", + "jue mayormente despejado 3\n", + "vie despejado 5\n", + "sáb despejado 5\n", + "dom parcialmente soleado 1\n" + ] + } + ], + "source": [ + "# str.replace() — reemplazar texto (§8.3.2)\n", + "df_cat2 = df_cat.copy()\n", + "df_cat2.loc[:, 'nubes'] = df_cat2['nubes'].str.replace('nublado', 'soleado')\n", + "print(df_cat2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## Nivel 9 — Fechas y Tiempos (§8.3.3)\n", + "\n", + "`pd.to_datetime()` convierte strings a objetos `datetime64` para series de tiempo." + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tipo original: object\n", + "Tipo convertido: datetime64[ns]\n", + "0 2020-01-01 12:34:00\n", + "1 2020-03-01 08:47:00\n", + "2 2020-06-01 14:23:00\n", + "3 2020-09-01 22:56:00\n", + "4 2020-12-01 13:45:00\n", + "dtype: datetime64[ns]\n" + ] + } + ], + "source": [ + "# pd.to_datetime() — convertir strings a fechas (§8.3.3)\n", + "fechas = pd.Series(['2020-01-01 12:34', '2020-03-01 08:47',\n", + " '2020-06-01 14:23', '2020-09-01 22:56',\n", + " '2020-12-01 13:45'])\n", + "\n", + "print(\"Tipo original:\", fechas.dtype)\n", + "fechas = pd.to_datetime(fechas)\n", + "print(\"Tipo convertido:\", fechas.dtype)\n", + "print(fechas)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Horas:\n", + "0 12:34:00\n", + "1 08:47:00\n", + "2 14:23:00\n", + "3 22:56:00\n", + "4 13:45:00\n", + "dtype: object\n", + "\n", + "Meses: [ 1 3 6 9 12]\n" + ] + } + ], + "source": [ + "# Acceder a componentes con el accessor .dt (§8.3.3)\n", + "print(\"Horas:\")\n", + "print(fechas.dt.time)\n", + "print(\"\\nMeses:\", fechas.dt.month.values)" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Diferencia respecto al primer registro:\n", + "0 0 days 00:00:00\n", + "1 59 days 20:13:00\n", + "2 152 days 01:49:00\n", + "3 244 days 10:22:00\n", + "4 335 days 01:11:00\n", + "dtype: timedelta64[ns]\n", + "\n", + "En segundos (float):\n" + ] + }, + { + "ename": "TypeError", + "evalue": "Cannot cast TimedeltaArray to dtype float64", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mTypeError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[40]\u001b[39m\u001b[32m, line 7\u001b[39m\n\u001b[32m 3\u001b[39m print(\u001b[33m\"Diferencia respecto al primer registro:\"\u001b[39m)\n\u001b[32m 4\u001b[39m print(delta)\n\u001b[32m 5\u001b[39m \n\u001b[32m 6\u001b[39m print(\u001b[33m\"\\nEn segundos (float):\"\u001b[39m)\n\u001b[32m----> \u001b[39m\u001b[32m7\u001b[39m print(delta.astype(\u001b[33m'timedelta64[s]'\u001b[39m).astype(float))\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Programs\\Python\\Python313\\Lib\\site-packages\\pandas\\core\\generic.py:6665\u001b[39m, in \u001b[36mNDFrame.astype\u001b[39m\u001b[34m(self, dtype, copy, errors)\u001b[39m\n\u001b[32m 6661\u001b[39m ]\n\u001b[32m 6662\u001b[39m \n\u001b[32m 6663\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 6664\u001b[39m \u001b[38;5;66;03m# else, only a single dtype is given\u001b[39;00m\n\u001b[32m-> \u001b[39m\u001b[32m6665\u001b[39m new_data = self._mgr.astype(dtype=dtype, copy=copy, errors=errors)\n\u001b[32m 6666\u001b[39m res = self._constructor_from_mgr(new_data, axes=new_data.axes)\n\u001b[32m 6667\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m res.__finalize__(self, method=\u001b[33m\"astype\"\u001b[39m)\n\u001b[32m 6668\u001b[39m \n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Programs\\Python\\Python313\\Lib\\site-packages\\pandas\\core\\internals\\managers.py:449\u001b[39m, in \u001b[36mBaseBlockManager.astype\u001b[39m\u001b[34m(self, dtype, copy, errors)\u001b[39m\n\u001b[32m 446\u001b[39m \u001b[38;5;28;01melif\u001b[39;00m using_copy_on_write():\n\u001b[32m 447\u001b[39m copy = \u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m449\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mapply\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 450\u001b[39m \u001b[43m \u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mastype\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 451\u001b[39m \u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[43m=\u001b[49m\u001b[43mdtype\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 452\u001b[39m \u001b[43m \u001b[49m\u001b[43mcopy\u001b[49m\u001b[43m=\u001b[49m\u001b[43mcopy\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 453\u001b[39m \u001b[43m \u001b[49m\u001b[43merrors\u001b[49m\u001b[43m=\u001b[49m\u001b[43merrors\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 454\u001b[39m \u001b[43m \u001b[49m\u001b[43musing_cow\u001b[49m\u001b[43m=\u001b[49m\u001b[43musing_copy_on_write\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 455\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Programs\\Python\\Python313\\Lib\\site-packages\\pandas\\core\\internals\\managers.py:363\u001b[39m, in \u001b[36mBaseBlockManager.apply\u001b[39m\u001b[34m(self, f, align_keys, **kwargs)\u001b[39m\n\u001b[32m 361\u001b[39m applied = b.apply(f, **kwargs)\n\u001b[32m 362\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m--> \u001b[39m\u001b[32m363\u001b[39m applied = \u001b[38;5;28;43mgetattr\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mb\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mf\u001b[49m\u001b[43m)\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 364\u001b[39m result_blocks = extend_blocks(applied, result_blocks)\n\u001b[32m 366\u001b[39m out = \u001b[38;5;28mtype\u001b[39m(\u001b[38;5;28mself\u001b[39m).from_blocks(result_blocks, \u001b[38;5;28mself\u001b[39m.axes)\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Programs\\Python\\Python313\\Lib\\site-packages\\pandas\\core\\internals\\blocks.py:784\u001b[39m, in \u001b[36mBlock.astype\u001b[39m\u001b[34m(self, dtype, copy, errors, using_cow, squeeze)\u001b[39m\n\u001b[32m 781\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[33m\"\u001b[39m\u001b[33mCan not squeeze with more than one column.\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m 782\u001b[39m values = values[\u001b[32m0\u001b[39m, :] \u001b[38;5;66;03m# type: ignore[call-overload]\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m784\u001b[39m new_values = \u001b[43mastype_array_safe\u001b[49m\u001b[43m(\u001b[49m\u001b[43mvalues\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcopy\u001b[49m\u001b[43m=\u001b[49m\u001b[43mcopy\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43merrors\u001b[49m\u001b[43m=\u001b[49m\u001b[43merrors\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 786\u001b[39m new_values = maybe_coerce_values(new_values)\n\u001b[32m 788\u001b[39m refs = \u001b[38;5;28;01mNone\u001b[39;00m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Programs\\Python\\Python313\\Lib\\site-packages\\pandas\\core\\dtypes\\astype.py:237\u001b[39m, in \u001b[36mastype_array_safe\u001b[39m\u001b[34m(values, dtype, copy, errors)\u001b[39m\n\u001b[32m 234\u001b[39m dtype = dtype.numpy_dtype\n\u001b[32m 236\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m--> \u001b[39m\u001b[32m237\u001b[39m new_values = \u001b[43mastype_array\u001b[49m\u001b[43m(\u001b[49m\u001b[43mvalues\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcopy\u001b[49m\u001b[43m=\u001b[49m\u001b[43mcopy\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 238\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m (\u001b[38;5;167;01mValueError\u001b[39;00m, \u001b[38;5;167;01mTypeError\u001b[39;00m):\n\u001b[32m 239\u001b[39m \u001b[38;5;66;03m# e.g. _astype_nansafe can fail on object-dtype of strings\u001b[39;00m\n\u001b[32m 240\u001b[39m \u001b[38;5;66;03m# trying to convert to float\u001b[39;00m\n\u001b[32m 241\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m errors == \u001b[33m\"\u001b[39m\u001b[33mignore\u001b[39m\u001b[33m\"\u001b[39m:\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Programs\\Python\\Python313\\Lib\\site-packages\\pandas\\core\\dtypes\\astype.py:179\u001b[39m, in \u001b[36mastype_array\u001b[39m\u001b[34m(values, dtype, copy)\u001b[39m\n\u001b[32m 175\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m values\n\u001b[32m 177\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(values, np.ndarray):\n\u001b[32m 178\u001b[39m \u001b[38;5;66;03m# i.e. ExtensionArray\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m179\u001b[39m values = \u001b[43mvalues\u001b[49m\u001b[43m.\u001b[49m\u001b[43mastype\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdtype\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcopy\u001b[49m\u001b[43m=\u001b[49m\u001b[43mcopy\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 181\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 182\u001b[39m values = _astype_nansafe(values, dtype, copy=copy)\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Programs\\Python\\Python313\\Lib\\site-packages\\pandas\\core\\arrays\\timedeltas.py:363\u001b[39m, in \u001b[36mTimedeltaArray.astype\u001b[39m\u001b[34m(self, dtype, copy)\u001b[39m\n\u001b[32m 357\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 358\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[32m 359\u001b[39m \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mCannot convert from \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mself\u001b[39m.dtype\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m to \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mdtype\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m. \u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 360\u001b[39m \u001b[33m\"\u001b[39m\u001b[33mSupported resolutions are \u001b[39m\u001b[33m'\u001b[39m\u001b[33ms\u001b[39m\u001b[33m'\u001b[39m\u001b[33m, \u001b[39m\u001b[33m'\u001b[39m\u001b[33mms\u001b[39m\u001b[33m'\u001b[39m\u001b[33m, \u001b[39m\u001b[33m'\u001b[39m\u001b[33mus\u001b[39m\u001b[33m'\u001b[39m\u001b[33m, \u001b[39m\u001b[33m'\u001b[39m\u001b[33mns\u001b[39m\u001b[33m'\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 361\u001b[39m )\n\u001b[32m--> \u001b[39m\u001b[32m363\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mdtl\u001b[49m\u001b[43m.\u001b[49m\u001b[43mDatetimeLikeArrayMixin\u001b[49m\u001b[43m.\u001b[49m\u001b[43mastype\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcopy\u001b[49m\u001b[43m=\u001b[49m\u001b[43mcopy\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Programs\\Python\\Python313\\Lib\\site-packages\\pandas\\core\\arrays\\datetimelike.py:517\u001b[39m, in \u001b[36mDatetimeLikeArrayMixin.astype\u001b[39m\u001b[34m(self, dtype, copy)\u001b[39m\n\u001b[32m 513\u001b[39m \u001b[38;5;28;01melif\u001b[39;00m (dtype.kind \u001b[38;5;129;01min\u001b[39;00m \u001b[33m\"\u001b[39m\u001b[33mmM\u001b[39m\u001b[33m\"\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m.dtype != dtype) \u001b[38;5;129;01mor\u001b[39;00m dtype.kind == \u001b[33m\"\u001b[39m\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m:\n\u001b[32m 514\u001b[39m \u001b[38;5;66;03m# disallow conversion between datetime/timedelta,\u001b[39;00m\n\u001b[32m 515\u001b[39m \u001b[38;5;66;03m# and conversions for any datetimelike to float\u001b[39;00m\n\u001b[32m 516\u001b[39m msg = \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mCannot cast \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mtype\u001b[39m(\u001b[38;5;28mself\u001b[39m).\u001b[34m__name__\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m to dtype \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mdtype\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m\n\u001b[32m--> \u001b[39m\u001b[32m517\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(msg)\n\u001b[32m 518\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 519\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m np.asarray(\u001b[38;5;28mself\u001b[39m, dtype=dtype)\n", + "\u001b[31mTypeError\u001b[39m: Cannot cast TimedeltaArray to dtype float64" + ] + } + ], + "source": [ + "# Diferencias de tiempo — timedelta (§8.3.3)\n", + "delta = fechas - fechas.iloc[0]\n", + "print(\"Diferencia respecto al primer registro:\")\n", + "print(delta)\n", + "\n", + "print(\"\\nEn segundos (float):\")\n", + "print(delta.astype('timedelta64[s]').astype(float))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## Nivel 10 — Funciones de Agregación (§8.4)\n", + "\n", + "Pandas provee métodos **agregadores** (producen un escalar) y **no-agregadores** (misma longitud que la entrada).\n", + "\n", + "| Agregadores | | | |\n", + "|---|---|---|---|\n", + "| `count()` | `sum()` | `mean()` | `max()` |\n", + "| `min()` | `median()` | `std()` | `var()` |\n", + "| `prod()` | `quantile(x)` | `abs()` | |\n", + "\n", + "| No-agregadores | | |\n", + "|---|---|---|\n", + "| `cumsum()` | `cumprod()` | `cummax()` |\n", + "| `cummin()` | | |" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# agg() con lista de métodos (§8.4)\n", + "print(\"Estadísticas de temperatura y lluvia:\")\n", + "print(df_clima[['temp_C', 'rain_mm']].agg(['min', 'max', 'mean']).round(2))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# agg() con diccionario — distintas métricas por columna (§8.4)\n", + "resultado = df_clima[['temp_C', 'rain_mm']].agg({\n", + " 'temp_C': ['min', 'max', 'mean'],\n", + " 'rain_mm': ['sum', 'median']\n", + "})\n", + "print(resultado.round(2))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# apply() — función personalizada por columna (§8.4)\n", + "def rango(col):\n", + " return col.max() - col.min()\n", + "\n", + "print(\"Rango (max - min) por columna numérica:\")\n", + "print(df_clima[['temp_C', 'rain_mm']].apply(rango))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## Nivel 11 — Visualización con Pandas (§8.5)\n", + "\n", + "Pandas ofrece métodos de graficación directa sobre DataFrames y Series que usan Matplotlib internamente." + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# df.plot() — gráfica de línea (§8.5)\n", + "fig, axes = plt.subplots(1, 2, figsize=(12, 4))\n", + "\n", + "df_clima['temp_C'].plot(kind='line', ax=axes[0], marker='o', color='tomato')\n", + "axes[0].set_title('Temperatura mensual promedio')\n", + "axes[0].set_ylabel('°C')\n", + "axes[0].grid(True, alpha=0.3)\n", + "\n", + "df_clima['rain_mm'].plot(kind='bar', ax=axes[1], color='steelblue', alpha=0.8)\n", + "axes[1].set_title('Lluvia mensual')\n", + "axes[1].set_ylabel('mm')\n", + "axes[1].tick_params(axis='x', rotation=45)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# df.hist() — histogramas de todas las columnas numéricas (§8.5)\n", + "df_clima.hist(figsize=(8, 4))\n", + "plt.suptitle('Distribución de variables climáticas', y=1.02)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# value_counts().plot() — histograma de datos categóricos (§8.5)\n", + "fig, ax = plt.subplots(figsize=(6, 4))\n", + "df_cat['nubes'].value_counts().plot(kind='bar', ax=ax, color='slategray')\n", + "ax.set_title('Frecuencia de tipos de nubosidad')\n", + "ax.set_ylabel('Días')\n", + "ax.tick_params(axis='x', rotation=30)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## Nivel 12 — Consejos de Pandas (§8.7)" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reporte climático mensual:\n", + " jan: -0.3°C, 59 mm de lluvia\n", + " feb: 0.4°C, 57 mm de lluvia\n", + " mar: 3.9°C, 84 mm de lluvia\n", + " apr: 7.4°C, 100 mm de lluvia\n", + " may: 12.0°C, 143 mm de lluvia\n", + " jun: 15.0°C, 153 mm de lluvia\n", + " jul: 17.2°C, 172 mm de lluvia\n", + " aug: 16.8°C, 164 mm de lluvia\n", + " sep: 13.1°C, 135 mm de lluvia\n", + " oct: 9.1°C, 89 mm de lluvia\n", + " nov: 3.7°C, 88 mm de lluvia\n", + " dec: 0.8°C, 80 mm de lluvia\n" + ] + } + ], + "source": [ + "# iterrows() — iterar sobre filas (§8.7)\n", + "print(\"Reporte climático mensual:\")\n", + "for mes, datos in df_clima.iterrows():\n", + " print(f\" {mes:>3}: {datos['temp_C']:5.1f}°C, {datos['rain_mm']:3.0f} mm de lluvia\")" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Temperatura media según si llueve ≥ 100 mm:\n", + "rain_mm\n", + "False 2.93\n", + "True 13.58\n", + "Name: temp_C, dtype: float64\n" + ] + } + ], + "source": [ + "# groupby() con condición booleana (§8.7)\n", + "print(\"Temperatura media según si llueve ≥ 100 mm:\")\n", + "print(df_clima.groupby(df_clima['rain_mm'] >= 100)['temp_C'].mean().round(2))" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Meses cálidos (> 10°C):\n", + " temp_C temp_F rain_mm\n", + "jul 17.2 62.96 172\n", + "aug 16.8 62.24 164\n", + "jun 15.0 59.00 153\n", + "sep 13.1 55.58 135\n", + "may 12.0 53.60 143\n" + ] + } + ], + "source": [ + "# Encadenar métodos — flujo de trabajo legible\n", + "resumen = (df_clima\n", + " .assign(temp_F=lambda d: d['temp_C'] * 1.8 + 32)\n", + " .loc[df_clima['temp_C'] > 10, ['temp_C', 'temp_F', 'rain_mm']]\n", + " .sort_values('temp_C', ascending=False)\n", + ")\n", + "print(\"Meses cálidos (> 10°C):\")\n", + "print(resumen)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "## Ejercicios" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Ejercicio 1\n", + "Crea una Serie con los valores de precipitación mensual de tu ciudad.\n", + "Calcula: media, mediana, máximo y el mes con mayor precipitación (`argmax()`)." + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Media: 68.33333333333333\n", + "Mediana: 60.0\n", + "Máximo: 120\n", + "Mes mayor lluvia: Jun\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "precipitacion = pd.Series([50, 40, 60, 80, 100, 120, 90, 70, 60, 55, 45, 50],\n", + " index=[\"Ene\",\"Feb\",\"Mar\",\"Abr\",\"May\",\"Jun\",\n", + " \"Jul\",\"Ago\",\"Sep\",\"Oct\",\"Nov\",\"Dic\"])\n", + "\n", + "print(\"Media:\", precipitacion.mean())\n", + "print(\"Mediana:\", precipitacion.median())\n", + "print(\"Máximo:\", precipitacion.max())\n", + "\n", + "print(\"Mes mayor lluvia:\", precipitacion.idxmax())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Ejercicio 2\n", + "Dado `df_clima`, filtra los meses con temperatura entre 5°C y 15°C.\n", + "Calcula la lluvia total en ese subconjunto." + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " mes temp lluvia\n", + "0 Ene 10 50\n", + "1 Feb 12 60\n", + "3 Abr 8 30\n", + "4 May 14 20\n", + "Lluvia total: 160\n" + ] + } + ], + "source": [ + "df_clima = pd.DataFrame({\n", + " \"mes\": [\"Ene\",\"Feb\",\"Mar\",\"Abr\",\"May\"],\n", + " \"temp\": [10, 12, 18, 8, 14],\n", + " \"lluvia\": [50, 60, 40, 30, 20]\n", + "})\n", + "\n", + "filtro = df_clima[(df_clima[\"temp\"] >= 5) & (df_clima[\"temp\"] <= 15)]\n", + "\n", + "print(filtro)\n", + "\n", + "print(\"Lluvia total:\", filtro[\"lluvia\"].sum())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Ejercicio 3\n", + "Agrega al DataFrame `df_completo` (con `temp_min_C` y `temp_max_C`) una columna\n", + "`amplitud_termica = temp_max_C - temp_min_C`. Encuentra el mes con mayor amplitud." + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " mes temp_min_C temp_max_C amplitud_termica\n", + "0 Ene 5 15 10\n", + "1 Feb 7 20 13\n", + "2 Mar 10 25 15\n", + "Mayor amplitud: mes Mar\n", + "temp_min_C 10\n", + "temp_max_C 25\n", + "amplitud_termica 15\n", + "Name: 2, dtype: object\n" + ] + } + ], + "source": [ + "df_completo = pd.DataFrame({\n", + " \"mes\": [\"Ene\",\"Feb\",\"Mar\"],\n", + " \"temp_min_C\": [5, 7, 10],\n", + " \"temp_max_C\": [15, 20, 25]\n", + "})\n", + "\n", + "df_completo[\"amplitud_termica\"] = df_completo[\"temp_max_C\"] - df_completo[\"temp_min_C\"]\n", + "\n", + "print(df_completo)\n", + "\n", + "print(\"Mayor amplitud:\", df_completo.loc[df_completo[\"amplitud_termica\"].idxmax()])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Ejercicio 4\n", + "Crea un DataFrame con 5 estudiantes (nombre, nota1, nota2, nota3) con 3 valores NaN. \n", + "a) Identifica cuántos NaN hay por columna. \n", + "b) Rellena con la media de cada columna. \n", + "c) Calcula la nota promedio final de cada estudiante." + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "nombre 0\n", + "nota1 2\n", + "nota2 1\n", + "nota3 1\n", + "dtype: int64\n", + " nombre nota1 nota2 nota3 promedio\n", + "0 A 80.0 85.0 90.00 85.000000\n", + "1 B 80.0 88.0 92.00 86.666667\n", + "2 C 90.0 82.0 85.00 85.666667\n", + "3 D 70.0 75.0 88.75 77.916667\n", + "4 E 80.0 80.0 88.00 82.666667\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "df_est = pd.DataFrame({\n", + " \"nombre\": [\"A\",\"B\",\"C\",\"D\",\"E\"],\n", + " \"nota1\": [80, np.nan, 90, 70, np.nan],\n", + " \"nota2\": [85, 88, np.nan, 75, 80],\n", + " \"nota3\": [90, 92, 85, np.nan, 88]\n", + "})\n", + "\n", + "# NaN por columna\n", + "print(df_est.isna().sum())\n", + "\n", + "# Rellenar con media\n", + "df_est.fillna(df_est.mean(numeric_only=True), inplace=True)\n", + "\n", + "# Promedio final\n", + "df_est[\"promedio\"] = df_est[[\"nota1\",\"nota2\",\"nota3\"]].mean(axis=1)\n", + "\n", + "print(df_est)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tarea 5 (opcional) — Pandas en Práctica\n", + "\n", + "La programación se aprende haciendo. Esta tarea tiene dos partes:\n", + "\n", + "**Parte 1 — Descarga y ejecuta** (obligatorio)\n", + "Descarga este notebook y ejecútalo celda por celda en tu computadora. \n", + "Verifica que todas las celdas corran sin errores antes de continuar.\n", + "\n", + "**Parte 2 — Ejercicios** (obligatorio) \n", + "Resuelve los ejercicios de la sección anterior (Ejercicios 1 al 4).\n", + "\n", + "**Parte 3 — Dataset real** (opcional, puntos extra) \n", + "Descarga cualquier dataset CSV que te interese y aplica al menos 3 herramientas vistas:\n", + "lectura, limpieza, `groupby`, visualización. \n", + "Agrega una celda Markdown con tus conclusiones.\n", + "\n", + "**Entrega: 1 de mayo** \n", + "Sube el notebook a tu repositorio de GitHub y envía el **link directo al archivo `.ipynb`**.\n", + "El notebook debe tener todas las celdas ya ejecutadas (con outputs visibles).\n", + "\n", + "Ejemplo de link válido: \n", + "`https://github.com/tu-usuario/tu-repo/blob/main/Pandas.ipynb`" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.7" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}