01: Fundamentos

Presencial

Autor/a

Victor Adrian

Fecha de publicación

2026-03-17

¿Cómo pensar programáticamente?

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.

Esto es:

  • Descomponer en partes más pequeñas
  • Definir y analizar lo esencial
  • Identificar patrones
  • Crear un paso a paso ordenado para la solución

Ejemplo: ¿cómo afectó la suba de precio del barril de crudo a la cotización de las empresas energéticas locales?

  1. Obtener/descargar datos históricos del precio del barril de Brent en sitios como Investing, para los últimos dos años.
  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.
  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.
  4. Graficar los índices y la ecuación lineal.
  5. Analizar los desvíos y la robustez del coeficiente de correlación entre las variables.

Tipos y estructuras de datos

Los tipos más comunes son:

  • texto/string
  • entero/integer
  • real/double
  • fecha/date
  • boolean (verdadero, falso o NA)
  • categórico/categorical (etiqueta, ej.: alto, medio, bajo)

Y las estructuras (datos agrupados para su organización):

  • vector (secuencia ordenada de elementos de igual tipo)
  • lista (“bolsa de gato”, puede incluir desde tablas enteras hasta textos)
  • tabla/data frame (estructura común en ciencia de datos con variables (columnas) y observaciones (filas))
  • matriz (tabla numérica sin nombres de columna)

Variables y asignación

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.

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.

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.

Otros tips para nombrar variables —naming conventions— en R:

  • Usar snake case (forma o estilo de combinar palabras consistente en usar solo minúsculas y separar palabras con guión bajo [“_“])
  • Usar nombres descriptivos
  • Evitar abreviaturas
  • Sin espacios, sin mayúsculas
  • No empezar con números

Ejemplo: primera_marca_registrada es mejor que 1_Marca_Reg y marca registrada 1, que directamente no funcionaría por los espacios.

Nota 1: Para más info ver convenciones/estilos de nomenclatura.

Algoritmos

Los algoritmos son una secuencia o conjunto de instrucciones ordenadas, finitas y no ambiguas, cuyo propósito es resolver un problema.

  • Ordenadas: un algoritmo debe seguir pasos claros y precisos, enumerados o secuenciados de tal manera que no generen confusión.
  • Finitas: debe tener un comienzo y un final, un número finito de pasos para resolver el problema.
  • No ambiguas: si yo sigo el algoritmo n veces, debo llegar a la misma solución n veces.

Los pasos para resolver un problema son: 1. Diseño del algoritmo 2. Expresión del algoritmo a un programa 3. Ejecución y validación del programa en una máquina

Todo algoritmo debe describir tres partes: entrada/input, proceso y salida/output.

Nota 2: Definición a partir de PDF de clase 01 y video de ProgramacionATS en YouTube.

Diseño

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?

Para representar visualmente un algoritmo existen diversas maneras, siendo las más comunes el diagrama de flujos y el pseudocódigo.

Diagrama de flujos

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:

  • Secuencias (se avanza unívoca y ordenadamente un paso atrás de otro)
  • Condicionales (se decide el camino a seguir según se cumplan o no condiciones establecidas)
  • Repetitivas (se vuelve uno o más pasos atrás para repetir una o más instrucciones/procesos)

Pseudocódigo

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.

Con pseudocódigo:

variable rango = rango de 1 a 10
por número en rango:
    si número divido 2 es igual a 0:
        imprime en pantalla {num} es un número par
    sino:
        imprime en pantalla {num} es un número impar

Con Python:

rango = range(1, 11)
for num in rango:
    if num % 2 == 0:
        print(f"{num} es un número par")
    else:
        print(f"{num} es un número impar")

Programación

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.

Ejecución y validación

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.

Ejercicio práctico

Consigna: Escribir algoritmos en pseudocódigo. Resto de ejercicios disponibles en PDF de clase 01.

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.

Código 
# Importo librería para construir data frame de ejemplo con Python
import pandas as pd
Código 
# Defino data frame de ejemplo para ejercicio
data = [["alumno_a", 5], ["alumno_b", 8], ["alumno_c", 3], ["alumno_d", 2], ["alumno_e", 9], ["alumno_f", 6]]
df = pd.DataFrame(data, columns=["cod_alumno", "nota"])
print(df)
  cod_alumno  nota
0   alumno_a     5
1   alumno_b     8
2   alumno_c     3
3   alumno_d     2
4   alumno_e     9
5   alumno_f     6

Pseudocódigo:

q_total_alumnos = 6
q_aprobados = 0
q_promocionados = 0
q_desaprobados = 0

contador = 0
mientras el contador sea menor a q_total_alumnos:
    si (nota >= 4):
        suma uno a q_aprobados
    si (nota >= 7):
        suma uno a q_promocionados
    si (nota < 4):
        suma uno a q_desaprobados
    contador suma 1 en cada iteración

imprime(alumnos aprobados: q_aprobados)
imprime(alumnos promocionados: q_promocionados)
imprime(alumnos aprobados, pero no promocionados: q_aprobados - q_procionados)
imprime(alumnos desaprobados: q_desaprobados)

si (q_aprobados + q_desaprobados) es igual a q_total_alumnos:
    imprime (la suma de aprobados y desaprobados coincide con el total)
Código 
# Check con Python
q_total_alumnos = df['cod_alumno'].nunique()
print(f"la cantidad total de alumnos es {q_total_alumnos}\n")
q_aprobados = 0
q_promocionados = 0
q_desaprobados = 0

i = 0
while i < q_total_alumnos:
    if (df["nota"][i]) >= 4:
        q_aprobados += 1
        if (df["nota"][i]) < 7:
            print(f"{df["cod_alumno"][i]} aprobó con {df["nota"][i]}")
    if (df["nota"][i]) >= 7:
        q_promocionados += 1
        print(f"{df["cod_alumno"][i]} promocionó con {df["nota"][i]}")
    if (df["nota"][i]) < 4:
        q_desaprobados += 1
        print(f"{df["cod_alumno"][i]} desaprobó con {df["nota"][i]}")
    i += 1

print(f"\nalumnos aprobados: {q_aprobados}")
print(f"alumnos promocionados: {q_promocionados}")
print(f"alumnos aprobados, pero no promocionados: {q_aprobados - q_desaprobados}")
print(f"alumnos desaprobados: {q_desaprobados}")

if (q_aprobados + q_desaprobados == q_total_alumnos):
    print("\nla suma de aprobados y desaprobados coincide con el total")