Qué es un algoritmo y cómo ejecuta Python tu programa línea por línea

Un algoritmo es una secuencia finita de pasos, sin ambigüedad, que lleva de una entrada a un resultado. Python ejecuta tu programa como lo haría un lector muy obediente con una receta: empieza en la primera línea del archivo, hace exactamente lo que ella manda, baja a la segunda, luego a la tercera, una instrucción cada vez, hasta que el texto se acaba o algo sale mal.

Casi todo error de quien está empezando viene de olvidar una de las mitades de esa frase. O el paso era vago (quien escribió sabía lo que quería decir, el computador no), o el orden estaba cambiado (la línea que usa un valor vino antes de la línea que lo crea). El texto que sigue muestra cómo ver las dos cosas en un programa pequeño, con código que abres y ejecutas en PyPlaca. Los ejemplos usan solo el Serial, sin ningún circuito. La ESP32 aparece solo al final, para mostrar dónde se va a usar esta base.

El problema: el computador no adivina

Imagina que un compañero de grupo recibe una nota: "calcula el promedio del grupo por mí". No necesita nada más. Sabe que las notas están en la planilla de la profesora, sabe que el promedio es sumar todo y dividir por la cantidad de alumnos, sabe que el resultado va al acta. Eran tres lagunas y se llenaron todas sin esfuerzo, porque las personas completan lo que falta.

El computador no completa nada. Si escribes solo "calcular el promedio", se queda sin respuesta para preguntas que nadie hizo. ¿Promedio de qué números? ¿Dónde están guardados? ¿Qué hacer con el resultado: guardarlo, mostrarlo, enviarlo? Cada pregunta sin respuesta es un paso que faltó en el algoritmo, y la máquina no pregunta de vuelta. Ejecuta lo que está escrito o se detiene con un mensaje de error.

Una comparación que ayuda es el camino explicado por teléfono. Alguien que nunca estuvo en tu barrio llama, perdido, y tú le dices "sigue derecho hasta el mercado y dobla en la calle de la panadería". Para ti está claro. Para quien escucha existen tres mercados y dos panaderías. Para que la persona llegue, el camino tiene que venir en pasos que solo admitan una lectura: "sigue por la calle de las Flores dos cuadras, dobla a la derecha en la primera calle después del semáforo, la escuela es el portón azul a la izquierda". Eso es un algoritmo. El orden también es parte de la instrucción, porque doblar antes de andar las dos cuadras lleva a otro lugar.

Lo mismo ocurre en el laboratorio. Un escenario común: la profesora pide "haz un programa que calcule el promedio del grupo" y dos alumnos entregan respuestas distintas, las dos defendibles. Uno sumó las notas de los 30 alumnos y dividió entre 30. El otro calculó solo el promedio de los aprobados, porque entendió "grupo" como quienes pasaron. Ninguno de los dos se equivocó en Python. El defecto estaba en el pedido, que dejaba abierto qué números entran en la cuenta. Solo después de que el grupo acuerda de dónde vienen los valores y qué debe aparecer al final, el código pasa a tener una respuesta correcta.

Qué es, al fin y al cabo, un algoritmo

Un algoritmo es la idea de cómo resolver un problema, escrita en pasos. No depende de un computador: la instrucción del camino de arriba es uno, el modo de preparación de una receta es otro, la manera de calcular el vuelto en el mercado también. Lo que separa un algoritmo de una lista de buenas intenciones son cuatro características:

• Finito: llega a un final. "Sigue sumando números para siempre" no es un algoritmo, es un problema.
• Preciso: cada paso tiene un único significado. "Añade un poco de sal" no sirve; "añade 5 gramos" sirve.
• Ordenado: la secuencia es parte de la respuesta. Cambiar dos pasos de lugar normalmente cambia el resultado o impide que exista.
• Con salida: puede tener entrada (los números que se van a sumar) o no tenerla, pero siempre produce algo que se puede observar, como un valor en la pantalla o un LED encendido.

Algoritmo y programa no son la misma cosa. El algoritmo es la idea, y el programa es esa idea escrita en un lenguaje que la máquina acepta. La misma idea puede convertirse en un programa en Python, otro en C, un dibujo en la pizarra o un texto en un cuaderno, y sigue siendo la misma idea.

Existe una excepción aparente a la regla de lo "finito" que aparece cuando llegas a las placas. Un programa de microcontrolador suele tener un while True: que nunca termina, porque la placa existe para repetir la tarea mientras esté encendida. Cada vuelta de ese bucle es finita y tiene principio, medio y final. Lo que no se acaba es la repetición, y eso es una elección de quien diseñó el programa. El artículo sobre programar sin colgarse muestra qué ocurre dentro de esa repetición.

Tres maneras de escribir el mismo algoritmo

Vamos a usar un problema pequeño: calcular el promedio de dos notas, 7,5 y 8,5, y mostrar el resultado. La figura muestra la misma solución escrita de tres maneras.

Cada forma sirve a un momento distinto del trabajo.

Si no consigues explicar el algoritmo en español, el código va a salir confuso, y ningún lenguaje lo arregla. Por ese motivo vale la pena escribir los pasos en una hoja antes de abrir el editor. El diagrama de flujo gana importancia en el próximo módulo de la serie, cuando surgen las decisiones: con if y else el programa deja de tener un único camino, y el dibujo muestra las bifurcaciones mejor que un párrafo.

Ahora el mismo algoritmo en Python. Haz clic en Abrir en el simulador, después en Ejecutar, y mira la pestaña Serial.

nota1 = 7.5
nota2 = 8.5
soma = nota1 + nota2
media = soma / 2
print("Promedio:", media)

Línea por línea, lo que hace cada una:

• nota1 = 7.5 se lee "guarda el valor 7.5 en un nombre llamado nota1". El nombre queda a la izquierda y el valor a la derecha. El signo = aquí es una orden, no una pregunta sobre igualdad.
• soma = nota1 + nota2 calcula primero el lado derecho, usando lo que nota1 y nota2 guardan en ese momento, y solo después guarda el resultado en soma.
• print("Promedio:", media) envía texto al Serial, el canal por donde el programa habla con quien lo está ejecutando. En la placa real, el Serial llega al computador por el cable USB. En PyPlaca, es la pestaña Serial. En un computador común sería la ventana de la terminal.

El resultado aparece como Promedio: 8.0 y no como Promedio: 8. La barra / de Python siempre devuelve un número decimal, incluso cuando la cuenta sale redonda: 10 / 2 muestra 5.0. La división que devuelve solo la parte entera existe, y es otra barra (//), que queda para el artículo sobre operadores.

Cómo lee Python tu archivo

Cuando pulsas Ejecutar, ocurren dos fases, en este orden.

En la primera, Python lee el archivo entero y comprueba si cada línea está escrita de una manera que él entiende: paréntesis cerrados, comillas en el lugar correcto, palabras del lenguaje escritas correctamente. Todavía no está ejecutando nada, solo verificando la gramática. Si alguna línea falla en esa comprobación, el programa no empieza. Ninguna de las líneas anteriores se ejecuta, ni siquiera las que estaban perfectas.

La segunda fase solo empieza si la primera pasó. Entonces Python ejecuta las instrucciones de arriba abajo, una después de otra. Cada vez que una línea crea una variable, el nombre y el valor entran en la memoria y se quedan ahí para que los usen las líneas siguientes. Un detalle que explica muchas cosas: Python no mira hacia adelante. Cuando está en la línea 3, no sabe qué va a crear la línea 7. Solo conoce lo que ya se ejecutó más arriba.

preco = 3.5
quantidade = 4
total = preco * quantidade
print("Total:", total)

La próxima figura acompaña este programa de cuatro líneas. A la izquierda está el código; a la derecha, lo que guardan la memoria y el Serial después de cada línea.

Después de la línea 1, solo existe preco. Después de la línea 2, existen preco y quantidade. Solo en la línea 3 tiene Python todo lo que necesita para calcular preco * quantidade, y solo en la línea 4 aparece algo en el Serial. Si inviertes el orden y pones la cuenta antes de las dos primeras líneas, Python llega a la cuenta sin tener nada guardado y protesta. Eso aparece más adelante, en la parte sobre errores.

Guardar de nuevo en el mismo nombre

Un nombre de variable puede recibir un valor nuevo tantas veces como quieras. El valor antiguo desaparece, y el nombre pasa a apuntar al nuevo.

pontos = 10
print(pontos)
pontos = pontos + 5
print(pontos)
pontos = pontos * 2
print(pontos)

La línea pontos = pontos + 5 asusta a quien viene de las matemáticas, donde ningún número es igual a sí mismo más cinco. En Python no hay contradicción, porque el = no afirma igualdad, manda guardar. El computador resuelve primero la cuenta de la derecha (10 más 5, que da 15) y después guarda el 15 en el nombre que está a la izquierda. En la línea siguiente, pontos vale 15, y la multiplicación por 2 produce 30. Este patrón de tomar el valor actual, calcular y guardar de vuelta es el más común de toda la programación: los contadores, las sumas acumuladas y los marcadores de los juegos funcionan así.

Lo que Python ignora

No todo en el archivo es una orden. Python descarta todo lo que viene después de un # hasta el final de la línea, y también las líneas en blanco.

# esto es un comentario: Python lo ignora
x = 2   # también ignora desde aquí hasta el final de la línea

y = 3

print(x + y)

Los comentarios sirven para ti, no para la máquina. Un buen comentario explica por qué existe una línea, no repite lo que hace.

Los espacios al comienzo de la línea, en cambio, no se ignoran. En Python, la sangría (la indentación) forma parte de la sintaxis, y una línea común no puede empezar más adentro que la anterior sin motivo. Escribir print("a") y, en la línea de abajo, print("b") con cuatro espacios delante produce IndentationError: unexpected indent, un error de la primera fase, que impide que el programa entero empiece. La sangría gana un papel central cuando lleguemos a las decisiones y los bucles, y en ese punto deja de ser una molestia y pasa a ser la manera de decir qué líneas pertenecen a qué.

Dos errores que se comportan de maneras opuestas

Quien aprende suele tratar todo mensaje rojo como la misma cosa. En la práctica hay dos familias, y saber en cuál caíste ahorra mucho tiempo.

El error de sintaxis (SyntaxError) viene de la primera fase. Como Python comprueba el archivo entero antes de ejecutar, no llega a ejecutarse nada. En el panel de la izquierda de la figura, la línea 1 es un print("antes") perfecto, pero no aparece, porque la línea 2 estaba mal formada. Quien ve el Serial mostrando solo el error suele pensar que el programa "ni siquiera empezó", y es exactamente eso lo que pasó.

El error de ejecución viene de la segunda fase. El archivo estaba gramaticalmente correcto, Python empezó, fue ejecutando línea por línea y cayó en una instrucción que no consigue cumplir, como dividir entre cero o usar un nombre que no existe. Lo que ya se ejecutó antes sigue valiendo y ya salió en el Serial. Lo que viene después nunca se ejecuta.

Cómo leer el mensaje

PyPlaca muestra los errores en el mismo formato de MicroPython. Este programa tiene la cuenta antes de las variables:

total = preco * quantidade
preco = 3.5
quantidade = 4
print("Total:", total)

Y el mensaje en el Serial es este:

Traceback (most recent call last):
  File "main.py", line 1, in <module>
NameError: name 'preco' isn't defined

La lectura más productiva empieza por la última línea, que trae el tipo del error y la explicación: NameError, el nombre preco no está definido. La línea de arriba dice dónde: main.py, línea 1. El trozo in <module> quiere decir que el error está en el nivel principal del archivo y no dentro de una función (las funciones llegan en el módulo 4). Con esas dos informaciones, ya sabes qué buscar: en la línea 1 hay un nombre que todavía no se creó.

Los mensajes de MicroPython son un poco distintos de los del Python del computador. MicroPython escribe name 'preco' isn't defined, y el Python de un computador común, name 'preco' is not defined. En la división entre cero, MicroPython dice divide by zero y el Python del computador, division by zero. En los errores de sintaxis, las versiones recientes del Python del computador llegan a sugerir lo que faltó ("Perhaps you forgot a comma?"), y MicroPython dice solo invalid syntax. La causa es la misma en los dos casos, solo cambia el texto.

Tabla de seguimiento: seguir el programa con el dedo

Existe una técnica antigua para descubrir lo que hace un programa sin ejecutarlo: la tabla de seguimiento (o prueba de escritorio). Dibujas una tabla con una columna para cada variable y una fila para cada paso, y vas rellenando a mano, ejecutando el programa como si fueras Python. Para el programa de los puntos, queda así:

Parece trabajoso para un programa tan corto, y lo es. El valor aparece cuando el programa no hace lo que esperabas. En vez de mirar el código e intentar "sentir" qué está mal, comparas lo que dice la tabla que debería ocurrir con lo que el Serial realmente mostró, y la primera línea en la que los dos divergen es donde está el defecto.

PyPlaca hace esa tabla por ti. Usa el botón Paso (atajo F10) para ejecutar una línea cada vez y abre la pestaña Variables. El programa se detiene antes de ejecutar la línea marcada en el editor, y la tabla muestra el valor de cada variable en ese instante, en orden alfabético. Si te pasas del punto, el botón de volver un paso (Ctrl+Shift+F10) deshace la última línea, y lo que ya salió en el Serial sigue ahí, como en una terminal de verdad. Es la figura de la memoria, solo que ocurriendo en la pantalla con tu programa.

Errores comunes del comienzo

Coma en lugar de punto

En muchos países escribimos 7,5. En Python, el separador decimal es el punto, y la coma tiene otro significado: separar valores. El problema es que nota1 = 7,5 es válido. Python no protesta en la línea 1, porque entiende que quieres guardar dos valores juntos, 7 y 5, en una colección llamada tupla.

nota1 = 7,5
nota2 = 8,5
soma = nota1 + nota2
media = soma / 2
print(media)

Este programa ejecuta las tres primeras líneas sin ningún aviso. El error solo aparece en la línea 4:

Traceback (most recent call last):
  File "main.py", line 4, in <module>
TypeError: unsupported types for __truediv__: 'tuple', 'int'

Si pusieras print(nota1) justo después de la línea 1, verías (7, 5) en el Serial, y la pista estaría clara. Aquí hay una lección que vale para muchos defectos: la línea que señala Python es donde él percibió el problema, y no necesariamente donde lo creaste. Cuando el error parece no tener sentido en esa línea, vuelve y comprueba de dónde vinieron los valores que usa.

La escena suele ser esta en el laboratorio: el alumno escribe 7,5 porque así anota la nota en el cuaderno, ejecuta el programa y recibe un error en la línea 4 que habla de tuple. Relee la línea 4, reescribe la cuenta, cambia el operador, y nada cambia, porque el defecto nunca estuvo ahí. Lo que deshace el nudo es la tabla de seguimiento. Al rellenar en la tabla el valor de nota1 después de la línea 1, aparece (7, 5) donde se esperaba 7.5, y la duda se acaba.

Calcular y no mostrar

Este programa se ejecuta de principio a fin sin ningún error y no muestra nada:

preco = 3.5
quantidade = 4
total = preco * quantidade

La cuenta se hizo, el resultado está en la memoria, y nadie pidió mostrarlo. Falta el print. Por eso "el programa no hace nada" no siempre quiere decir que esté roto: a veces solo no se le mandó mostrar el resultado.

Letra mayúscula y minúscula

Para Python, total y Total son nombres distintos, y print y Print también. Este programa:

total = 10
print(Total)

termina en NameError: name 'Total' isn't defined, porque la única variable creada fue total con t minúscula. Cuando el error diga que un nombre no está definido y el nombre parezca correcto, comprueba las mayúsculas.

Texto sin comillas

Escribir print(Maria) en vez de print("Maria") también produce un NameError. Sin comillas, Python piensa que Maria es el nombre de una variable y va a buscarla en la memoria. Las comillas dicen "esto es un texto, no es un nombre". Las comillas abiertas y no cerradas, como en print("Hola), en cambio, son un error de sintaxis de la primera fase, y el programa entero deja de ejecutarse.

Ejercicio: el vuelto de la compra

Compras 4 artículos de R$ 3,50 cada uno y pagas con un billete de R$ 20. Escribe el algoritmo que muestra el valor de la cuenta y el vuelto. Intenta primero en español, en un papel, y solo después escribe el Python.

Una respuesta posible, en español:

1. Guardar el precio de cada artículo: 3,50.
2. Guardar la cantidad de artículos: 4.
3. Calcular la cuenta: precio por cantidad.
4. Guardar el valor pagado: 20.
5. Calcular el vuelto: valor pagado menos la cuenta.
6. Mostrar la cuenta y el vuelto.

En Python, cada paso se convierte en una línea, en el mismo orden:

preco_item = 3.5
quantidade = 4
conta = preco_item * quantidade
pago = 20
troco = pago - conta
print("Cuenta:", conta)
print("Vuelto:", troco)

La tabla de seguimiento de este programa muestra una variable nueva en cada paso, y el vuelto solo se puede calcular después de que existan conta y pago:

Las líneas 6 y 7 solo muestran esos valores en el Serial: Cuenta: 14.0 y Vuelto: 6.0. Para practicar, cambia el precio, la cantidad y el valor pagado y escribe en el papel lo que esperas ver antes de ejecutar. Después invierte las líneas 4 y 5 e intenta prever el mensaje de error, el nombre y la línea, antes de ejecutar.

En un grupo, este problema suele dar dos soluciones. Una escribe la cuenta directamente, conta = 3.5 * 4, y funciona. La otra guarda precio y cantidad en variables antes de calcular, como en el código de arriba. Las dos muestran Vuelto: 6.0 hoy. La diferencia aparece cuando el enunciado cambia a 5 artículos de R$ 4,20: en la primera hay que cazar los números dentro de las cuentas, y en la segunda basta con tocar las dos primeras líneas. Vale la pena comparar las dos lado a lado antes de decidir cuál es la mejor.

Preguntas frecuentes

¿Necesito saber dibujar diagramas de flujo para programar?

No. El diagrama de flujo es una herramienta de razonamiento, y mucha gente prefiere escribir los pasos en español o hacer una tabla. Compensa más cuando el problema tiene muchos caminos, y lo notarás a partir de las decisiones.

¿Lee Python el archivo entero antes de ejecutar?

Lo lee, pero solo para comprobar la escritura. La ejecución de verdad ocurre después, línea por línea. Por eso un error de sintaxis en la última línea impide que se ejecute la primera, mientras que un error de ejecución en la última línea deja que corra todo lo que vino antes.

¿Python de la ESP32 corre igual que el del computador?

El núcleo del lenguaje es el mismo, y todo lo que mostró este artículo funciona igual. Las diferencias aparecen en los detalles: el texto de algunos mensajes de error, como se vio arriba, y los números decimales, que en la placa usan 32 bits de precisión. Por eso, 10 / 3 muestra 3.3333332 en la placa y en el simulador, mientras que el Python del computador muestra más decimales. Hay además módulos de la biblioteca estándar que, en la placa, traen menos funciones que en el computador. Cada artículo de la serie avisa cuando una de esas diferencias importa.

Para continuar

El camino natural es practicar en la ruta Lógica con Python, con 60 desafíos de lógica en Python. Tres de ellos encajan directamente con lo visto aquí: Hola Mundo, con una única línea de print; Suma de dos, para entrenar el cálculo y la salida; y Promedio de notas, que es el algoritmo de la primera figura con valores distintos. Al resolver, haz la tabla de seguimiento en el papel antes de enviar la respuesta y usa el botón Paso si el resultado no coincide.

El próximo tema de la serie es entrada y salida, es decir, cómo hacer que el programa pregunte un valor con input() y responda con print(). Si quieres ver la misma idea de ejecutar línea por línea moviendo un pin de verdad, el artículo Primeros pasos con MicroPython en la ESP32 hace parpadear un LED con el mismo main.py, y la ficha de la ESP32 DevKit V1 muestra la placa en la que se va a ejecutar ese código. Las rutas de hardware empiezan en Primeros pasos.