{ "cells": [ { "cell_type": "raw", "id": "1e1dc72b-9b2c-400f-8052-85b9f9fc7896", "metadata": { "vscode": { "languageId": "raw" } }, "source": [ "---\n", "title: \"01: Fundamentos\"\n", "subtitle: \"Presencial\"\n", "author: \"Victor Adrian\"\n", "format: html\n", "toc: true\n", "output-file: \"clase-01-20260317.html\"\n", "code-overflow: wrap\n", "jupyter: python3\n", "date: \"March 17, 2026\"\n", "date-format: \"iso\"\n", "embed-resources: true\n", "---" ] }, { "cell_type": "markdown", "id": "0ac806ee-84a2-48ec-a2f8-54aefea114fa", "metadata": { "jp-MarkdownHeadingCollapsed": true }, "source": [ "## ¿Cómo pensar programáticamente?" ] }, { "cell_type": "markdown", "id": "baedd248-552e-4466-a580-93fe0ff1686f", "metadata": {}, "source": [ "Debemos pensar de manera lógica y programable/estructurada —no necesariamente secuencial— cómo resolver un problema, de manera que tanto una computadora como una persona puedan comprender y abordar los pasos necesarios para su solución.\n", "\n", "Esto es:\n", "\n", "- Descomponer en partes más pequeñas\n", "- Definir y analizar lo esencial\n", "- Identificar patrones\n", "- Crear un paso a paso ordenado para la solución\n", "\n", "Ejemplo: ¿cómo afectó la suba de precio del barril de crudo a la cotización de las empresas energéticas locales?\n", "\n", "1. Obtener/descargar datos históricos del precio del barril de Brent en sitios como [Investing](https://www.investing.com/commodities/brent-oil-historical-data), para los últimos dos años.\n", "2. Hacer lo mismo con dos empresas representativas del sector, PAMP e YPFD, de administración privada y público-privada respectivamente, para el mismo periodo.\n", "3. Elaborar índices de igual base para las variables, agrupando a PAMP e YPFD en un mismo índice y establecer un modelo de regresión lineal con el precio del Brent.\n", "4. Graficar los índices y la ecuación lineal.\n", "5. Analizar los desvíos y la robustez del coeficiente de correlación entre las variables." ] }, { "cell_type": "markdown", "id": "b37775cd-4b1d-48da-8475-2c5e54b6e853", "metadata": { "jp-MarkdownHeadingCollapsed": true }, "source": [ "## Tipos y estructuras de datos" ] }, { "cell_type": "markdown", "id": "7a22ddf7-8b1c-4771-895e-9117057275d8", "metadata": {}, "source": [ "Los tipos más comunes son:\n", "\n", "- texto/*string*\n", "- entero/*integer*\n", "- real/*double*\n", "- fecha/*date*\n", "- boolean (verdadero, falso o NA)\n", "- categórico/*categorical* (etiqueta, ej.: alto, medio, bajo)\n", "\n", "Y las estructuras (datos agrupados para su organización):\n", "\n", "- vector (secuencia ordenada de elementos de igual tipo)\n", "- lista (\"bolsa de gato\", puede incluir desde tablas enteras hasta textos)\n", "- tabla/*data frame* (estructura común en ciencia de datos con variables (columnas) y observaciones (filas))\n", "- matriz (tabla numérica sin nombres de columna)" ] }, { "cell_type": "markdown", "id": "6b01e2bf-5835-4fe4-970c-294e6037b6e1", "metadata": { "jp-MarkdownHeadingCollapsed": true }, "source": [ "## Variables y asignación" ] }, { "cell_type": "markdown", "id": "db44b507-4d1b-4769-badd-0d465c1f2765", "metadata": {}, "source": [ "Una variable es la representación de uno o más valores (números, listas, tablas, etc.) tras la asignación de un nombre. También podría decirse que es un nombre que almacena valores en memoria.\n", "\n", "Su importancia radica en brindar escalabilidad, trazabilidad y síntesis a la hora de escribir código. Es más fácil recordar un nombre que el o los comandos que lo definen, y lo mismo si se reutiliza más de una vez en la sintaxis de un programa; además de hacer más sencillo llamar/usar a las propiedades del valor que almacena una vez recibe un nombre, dado que actúa como contenedor de un objeto con sus propias características.\n", "\n", "En R, las variables son *case sensitive*, es decir, este lenguaje diferencia entre minúsculas y mayúsculas; por lo tanto, `var_1` no es lo mismo que `Var_1`.\n", "\n", "Otros tips para nombrar variables *—naming conventions—* en R:\n", "\n", "- Usar *snake case* (forma o estilo de combinar palabras consistente en usar solo minúsculas y separar palabras con guión bajo \\[\"_\"])\n", "- Usar nombres descriptivos\n", "- Evitar abreviaturas \n", "- Sin espacios, sin mayúsculas\n", "- No empezar con números\n", "\n", "Ejemplo: `primera_marca_registrada` es mejor que `1_Marca_Reg` y `marca registrada 1`, que directamente no funcionaría por los espacios.\n", "\n", "> **Nota 1:** Para más info ver convenciones/estilos de nomenclatura." ] }, { "cell_type": "markdown", "id": "ffe04306-b22d-4369-b4dc-f1424cd9fc91", "metadata": { "jp-MarkdownHeadingCollapsed": true }, "source": [ "## Algoritmos" ] }, { "cell_type": "markdown", "id": "ed9b9f0d-f78e-4cec-867d-c8a50bf2d524", "metadata": {}, "source": [ "Los algoritmos son una secuencia o conjunto de **instrucciones ordenadas, finitas y no ambiguas,** cuyo propósito es resolver un problema.\n", "\n", "- Ordenadas: un algoritmo debe seguir pasos claros y precisos, enumerados o secuenciados de tal manera que no generen confusión.\n", "- Finitas: debe tener un comienzo y un final, un número finito de pasos para resolver el problema.\n", "- No ambiguas: si yo sigo el algoritmo n veces, debo llegar a la misma solución n veces.\n", "\n", "Los pasos para resolver un problema son:\n", "1. Diseño del algoritmo\n", "2. Expresión del algoritmo a un programa\n", "3. Ejecución y validación del programa en una máquina\n", "\n", "Todo algoritmo debe describir tres partes: **entrada/*input*, proceso y salida/*output*.**\n", "\n", "> **Nota 2:** Definición a partir de PDF de clase 01 y video de ProgramacionATS en YouTube." ] }, { "cell_type": "markdown", "id": "2938b9e4-7c4d-469c-a37e-b8dee7ebffb7", "metadata": { "jp-MarkdownHeadingCollapsed": true }, "source": [ "### Diseño" ] }, { "cell_type": "markdown", "id": "29c17f16-df61-4bfe-838a-f8bc42542b22", "metadata": {}, "source": [ "Involucra la creación del algoritmo, la secuencia de pasos/instrucciones finitas, ordenadas y no ambiguas para resolver un problema. Pero, **¿cómo lo representamos?**\n", "\n", "Para representar visualmente un algoritmo existen diversas maneras, siendo las más comunes el diagrama de flujos y el pseudocódigo." ] }, { "cell_type": "markdown", "id": "d44d2e7b-b0f0-45b7-b1eb-ed7913272c52", "metadata": { "jp-MarkdownHeadingCollapsed": true }, "source": [ "#### Diagrama de flujos" ] }, { "cell_type": "markdown", "id": "ef666bbd-6894-4193-a3e9-6ae336a72185", "metadata": {}, "source": [ "Es la representación gráfica de un algoritmo o proceso, que través de figuras geométricas y flechas expresa visualmente los pasos a seguir y las interrelaciones entre sí. Estas interrelaciones se conocen como **estructuras de control**, están presentes en todas las representaciones de un algoritmo, y permiten controlar su flujo/dirección. Entre ellas tenemos:\n", "\n", "- Secuencias (se avanza unívoca y ordenadamente un paso atrás de otro)\n", "- Condicionales (se decide el camino a seguir según se cumplan o no condiciones establecidas)\n", "- Repetitivas (se vuelve uno o más pasos atrás para repetir una o más instrucciones/procesos)\n", "\n", "\n", " " ] }, { "cell_type": "markdown", "id": "72b80237-dd13-47fd-a517-edea8526c7d3", "metadata": { "jp-MarkdownHeadingCollapsed": true }, "source": [ "#### Pseudocódigo" ] }, { "cell_type": "markdown", "id": "86c6b835-211b-46db-ac04-910641f1d744", "metadata": {}, "source": [ "Es la versión codificada de un algoritmo de acuerdo al lenguaje natural estructurado. Es decir, en vez de recordar nombres extraños o poco habituales de comandos, métodos, funciones, parámetros y propiedades, usamos palabras cotidianas. Como si pensáramos en voz alta cómo debe ser y qué debe hacer el algoritmo para solucionar el problema.\n", "\n", "Con pseudocódigo:\n", "\n", "```\n", "variable rango = rango de 1 a 10\n", "por número en rango:\n", " si número divido 2 es igual a 0:\n", " imprime en pantalla {num} es un número par\n", " sino:\n", " imprime en pantalla {num} es un número impar\n", "```\n", "\n", "Con Python:\n", "\n", "```python\n", "rango = range(1, 11)\n", "for num in rango:\n", " if num % 2 == 0:\n", " print(f\"{num} es un número par\")\n", " else:\n", " print(f\"{num} es un número impar\")\n", "```" ] }, { "cell_type": "markdown", "id": "c68547f5-468d-4b3c-8f26-1665cb473b8c", "metadata": { "jp-MarkdownHeadingCollapsed": true }, "source": [ "### Programación" ] }, { "cell_type": "markdown", "id": "f79a9920-ed62-44a6-8cda-b179fe37a24b", "metadata": {}, "source": [ "Involucra expresar el algoritmo como un programa, codificarlo o \"traducirlo\" a cualquier lenguaje de programación que se decida. Debemos recordar que **el algoritmo es completamente independiente de todo lenguaje de programación y máquina**. Puedo escribirlo en una hoja de papel usando palabras en jeringoso y aun así seguirá siendo un algoritmo." ] }, { "cell_type": "markdown", "id": "5f28d55d-4d3c-4f4a-9181-f2f58092500b", "metadata": { "jp-MarkdownHeadingCollapsed": true }, "source": [ "### Ejecución y validación" ] }, { "cell_type": "markdown", "id": "d5f77ee6-25ae-4b9a-ae2b-1b3e8bc9528e", "metadata": {}, "source": [ "Correr el código en una computadora, investigar y remediar cualquier error que pueda arrojar, evaluar su desempeño, buscar optimizaciones y, fundamentalmente, comprobar que el programa cumpla la finalidad para la cual se diseñó. La computadora traduce el código del programa —gracias a un intérprete (intermediario)— a un conjunto de instrucciones más cercanas al *hardware (bytecode)* para interactuar con la máquina, estas son luego ejecutadas por una máquina virtual (representación que el sistema puede ejecutar y correr), según cada lenguaje. El proceso de solución de errores se conoce como *debugging* (eliminación de bugs) y a veces se acompaña de otro proceso llamado *linting*, basado en el uso de herramientas que no corren código y se limitan a señalar cosas como variables inutilizadas, inconsistencia de formatos y posibles bugs." ] }, { "cell_type": "markdown", "id": "aed82734-fd60-4fc0-8aab-c414dd3ce62f", "metadata": {}, "source": [ "## Ejercicio práctico" ] }, { "attachments": {}, "cell_type": "markdown", "id": "b6732b04-cc49-4e4e-82ae-534517b7b97f", "metadata": {}, "source": [ "Consigna: Escribir algoritmos en pseudocódigo. Resto de ejercicios disponibles en PDF de clase 01.\n", "\n", "Caso 1: Dado un listado de notas de estudiantes (0 a 10), escribí un algoritmo que clasifique a cada estudiante como \"aprobado\" (nota >= 4), \"promocionado\" (nota >= 7) o \"desaprobado\" (nota < 4). Al final, mostrá cuántos hay en cada categoría." ] }, { "cell_type": "code", "execution_count": null, "id": "6f2b2a5a-90e0-43e9-b751-1ab729d4ddf4", "metadata": {}, "outputs": [], "source": [ "# Importo librería para construir data frame de ejemplo con Python\n", "import pandas as pd" ] }, { "cell_type": "code", "execution_count": null, "id": "55facb17-18dc-433b-a6b4-c1b8677f5a11", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " cod_alumno nota\n", "0 alumno_a 5\n", "1 alumno_b 8\n", "2 alumno_c 3\n", "3 alumno_d 2\n", "4 alumno_e 9\n", "5 alumno_f 6\n" ] } ], "source": [ "# Defino data frame de ejemplo para ejercicio\n", "data = [[\"alumno_a\", 5], [\"alumno_b\", 8], [\"alumno_c\", 3], [\"alumno_d\", 2], [\"alumno_e\", 9], [\"alumno_f\", 6]]\n", "df = pd.DataFrame(data, columns=[\"cod_alumno\", \"nota\"])\n", "print(df)" ] }, { "cell_type": "markdown", "id": "42d3c375-5e5a-42a6-a62a-92ddf69a3a49", "metadata": {}, "source": [ "Pseudocódigo:\n", "\n", "```\n", "q_total_alumnos = 6\n", "q_aprobados = 0\n", "q_promocionados = 0\n", "q_desaprobados = 0\n", "\n", "contador = 0\n", "mientras el contador sea menor a q_total_alumnos:\n", " si (nota >= 4):\n", " suma uno a q_aprobados\n", " si (nota >= 7):\n", " suma uno a q_promocionados\n", " si (nota < 4):\n", " suma uno a q_desaprobados\n", " contador suma 1 en cada iteración\n", "\n", "imprime(alumnos aprobados: q_aprobados)\n", "imprime(alumnos promocionados: q_promocionados)\n", "imprime(alumnos aprobados, pero no promocionados: q_aprobados - q_procionados)\n", "imprime(alumnos desaprobados: q_desaprobados)\n", "\n", "si (q_aprobados + q_desaprobados) es igual a q_total_alumnos:\n", " imprime (la suma de aprobados y desaprobados coincide con el total)\n", "```" ] }, { "cell_type": "code", "execution_count": null, "id": "811b2221-5af4-4f4d-94cc-edf7eb018847", "metadata": {}, "outputs": [], "source": [ "# Check con Python\n", "q_total_alumnos = df['cod_alumno'].nunique()\n", "print(f\"la cantidad total de alumnos es {q_total_alumnos}\\n\")\n", "q_aprobados = 0\n", "q_promocionados = 0\n", "q_desaprobados = 0\n", "\n", "i = 0\n", "while i < q_total_alumnos:\n", " if (df[\"nota\"][i]) >= 4:\n", " q_aprobados += 1\n", " if (df[\"nota\"][i]) < 7:\n", " print(f\"{df[\"cod_alumno\"][i]} aprobó con {df[\"nota\"][i]}\")\n", " if (df[\"nota\"][i]) >= 7:\n", " q_promocionados += 1\n", " print(f\"{df[\"cod_alumno\"][i]} promocionó con {df[\"nota\"][i]}\")\n", " if (df[\"nota\"][i]) < 4:\n", " q_desaprobados += 1\n", " print(f\"{df[\"cod_alumno\"][i]} desaprobó con {df[\"nota\"][i]}\")\n", " i += 1\n", "\n", "print(f\"\\nalumnos aprobados: {q_aprobados}\")\n", "print(f\"alumnos promocionados: {q_promocionados}\")\n", "print(f\"alumnos aprobados, pero no promocionados: {q_aprobados - q_desaprobados}\")\n", "print(f\"alumnos desaprobados: {q_desaprobados}\")\n", "\n", "if (q_aprobados + q_desaprobados == q_total_alumnos):\n", " print(\"\\nla suma de aprobados y desaprobados coincide con el total\")" ] } ], "metadata": { "kernelspec": { "display_name": "uni-py", "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.3" } }, "nbformat": 4, "nbformat_minor": 5 }