Python I: tu primer programa

La pregunta

¿Cuánto da 1 + 2 + 3 + … + 100? Con lápiz y papel tardarías varios minutos y es fácil equivocarse en alguna suma. Un programa de cuatro líneas lo resuelve en menos de un milisegundo, y no se cansa si le pides sumar hasta un millón.

Pero la computadora no entiende «suma todos los números hasta el 100». Entiende instrucciones muy pequeñas y muy precisas: «guarda este número», «súmale este otro», «repite esto tantas veces». Un programa es justamente eso: una lista de instrucciones que la computadora sigue al pie de la letra, una por una y en orden. Todo sistema de inteligencia artificial, desde el que separa el correo basura hasta el que conversa contigo, es un programa. Por eso la ruta empieza aquí.

En este tema vas a:

• abrir un cuaderno de Google Colab y ejecutar código en sus celdas;
• guardar datos en variables de cuatro tipos: números enteros (int), números con decimales (float), texto (str) y verdadero o falso (bool);
• hacer que el programa decida con if, elif y else, y que repita con for y while;
• leer un mensaje de error y corregir la línea que lo causa;
• programar una calculadora de IMC, la tabla de multiplicar y un juego de adivinar un número.

No necesitas saber nada de programación. Solo una cuenta de Google para usar Colab.

Actividad: paso a paso

Antes de escribir código, mira cómo lo lee la computadora. Abajo hay un programa de cuatro líneas que suma los números del 1 al 4. Cada vez que pulsas «Siguiente», la computadora ejecuta una sola línea: el punto marca la línea que acaba de correr, las cajas muestran lo que guarda cada variable en ese momento y la tabla va anotando cada paso.

Prueba esto, en orden:

1. Avanza paso a paso hasta el final. ¿Cuántas veces se ejecuta la línea 3? ¿Y la línea 2?
2. Mira la caja total cada vez que se ejecuta la línea 3. ¿Qué pasa con el valor que tenía antes?
3. Antes de llegar a la línea 4, predice qué va a imprimir el programa. Compruébalo.
4. Cambia al programa «Sumar solo los pares». Ahora hay una línea que a veces no se ejecuta. ¿Cuál es y de qué depende?

Dos ideas de esta actividad sostienen todo el tema. Primera: la computadora ejecuta una línea a la vez, y un bucle hace que vuelva a líneas que ya ejecutó. Segunda: una variable es una caja con nombre que guarda un valor; cuando le guardas uno nuevo, el anterior desaparece.

Dónde se escribe el código: Colab

Vas a escribir Python en Google Colab, un cuaderno que funciona en el navegador. No hay que instalar nada y corre igual en una computadora del colegio, en la de tu casa o en un celular (aunque con teclado es mucho más cómodo).

1. Entra a colab.research.google.com e inicia sesión con tu cuenta de Google.
2. Elige Nuevo cuaderno (también está en el menú Archivo). Se guarda solo en tu Google Drive, en una carpeta llamada Colab Notebooks.
3. Cambia el nombre del cuaderno haciendo clic en el título de arriba, por ejemplo tema1.ipynb.

Un cuaderno está hecho de celdas. Las celdas de código tienen un botón de reproducir a la izquierda: al pulsarlo (o con Mayúsculas + Enter) se ejecuta el código de esa celda y debajo aparece lo que imprime. Con + Código agregas otra celda y con + Texto, una celda para escribir notas.

Al lado de cada celda ejecutada aparece un número entre corchetes, como [1], [2], [3]: es el orden en que las ejecutaste, no el orden en que están escritas. Eso importa, porque el cuaderno recuerda las variables de una celda a otra. Si una celda usa una variable que se crea en otra celda que todavía no ejecutaste, dará error. Si algo se enreda, el menú Entorno de ejecución → Reiniciar sesión borra todo lo que el cuaderno recuerda, y Ejecutar todas corre las celdas de arriba abajo.

Escribe esto en la primera celda y ejecútala:

print("¡Hola, Bolivia!")
print("Este es mi primer programa.")

¡Hola, Bolivia!
Este es mi primer programa.

print muestra en la pantalla lo que pongas entre los paréntesis. El texto va entre comillas; si olvidas una, Python no sabe dónde termina y te avisa con un error (más adelante vas a aprender a leerlos).

Valores y tipos

Todo dato que maneja un programa es un valor, y cada valor tiene un tipo. En este tema usamos cuatro:

Ojo con los decimales: en Python se escriben con punto, no con coma. Una estatura de 1,65 m se escribe 1.65. La función type te dice de qué tipo es un valor:

print(type(17))
print(type(1.65))
print(type("Sucre"))
print(type(True))
print(type("42"))

<class 'int'>
<class 'float'>
<class 'str'>
<class 'bool'>
<class 'str'>

El último es un detalle importante: "42" está entre comillas, así que para Python es texto, no un número. Con los números se puede hacer aritmética:

print(7 + 2)
print(7 - 2)
print(7 * 2)
print(7 / 2)
print(7 // 2)
print(7 % 2)
print(7 ** 2)

9
5
14
3.5
3
1
49

• * multiplica y ** eleva a una potencia: 7 ** 2 es 7².
• / divide y siempre da un float, aunque la división sea exacta: 6 / 2 da 3.0.
• // es la división entera (cuántas veces cabe) y % es el resto. 7 entre 2 da 3 y sobra 1. El resto sirve mucho: un número es par cuando n % 2 vale 0.

Como en matemáticas, primero se calculan las potencias, después las multiplicaciones y divisiones, y al final las sumas y restas. Si quieres otro orden, usa paréntesis. El texto también tiene sus operaciones: + pega dos textos y * repite uno. len cuenta sus caracteres.

print(2 + 3 * 4)
print((2 + 3) * 4)
print("Hola" + " " + "mundo")
print("ja" * 3)
print(len("Cochabamba"))

14
20
Hola mundo
jajaja
10

Variables: cajas con nombre

Una variable es un nombre que guarda un valor, como la caja de la actividad. Se crea con el signo =:

edad = 15
nombre = "Ana"
print(nombre, "tiene", edad, "años")

edad = edad + 1
print(nombre, "ahora tiene", edad, "años")

Ana tiene 15 años
Ana ahora tiene 16 años

En Python, = no significa «es igual a» como en matemáticas: significa «calcula lo de la derecha y guárdalo en la caja de la izquierda». Por eso edad = edad + 1 tiene sentido: toma el valor actual de edad (15), le suma 1 y guarda el 16 en la misma caja. El 15 se pierde.

Cuando a print le das varias cosas separadas por comas, las muestra en una línea con un espacio entre cada una. Algunas reglas para los nombres:

• Pueden tener letras, números y guion bajo (nota_final, edad2), pero no pueden empezar con un número ni tener espacios.
• Mayúsculas y minúsculas cuentan: edad y Edad son dos cajas distintas.
• Elige nombres que digan qué guardan: precio se entiende mejor que p. Es costumbre escribirlos en minúsculas y sin tildes.

Juntar texto y números: f-strings

Para armar un mensaje con valores adentro, lo más cómodo es una f-string: un texto con una f antes de las comillas, donde lo que va entre llaves se calcula y se reemplaza por su valor.

nombre = "Ana"
edad = 16
print(f"{nombre} tiene {edad} años.")
print(f"El próximo año tendrá {edad + 1}.")

pi = 3.14159
print(f"Pi con dos decimales: {pi:.2f}")

Ana tiene 16 años.
El próximo año tendrá 17.
Pi con dos decimales: 3.14

El :.2f después del valor quiere decir «muéstralo con 2 decimales». ¿Y si intentas pegar texto y número con +?

edad = 16
print("Tengo " + edad + " años")

Traceback (most recent call last):
  ...
----> 2 print("Tengo " + edad + " años")

TypeError: can only concatenate str (not "int") to str

Es tu primer error. La última línea dice qué pasó: un TypeError (error de tipo), porque solo se puede «concatenar» (pegar) un str con otro str, no con un int. La flecha señala la línea 2 de la celda. Hay dos arreglos: usar una f-string, o convertir el número en texto con str. Las funciones int, float y str convierten de un tipo a otro:

print("Tengo " + str(edad) + " años")
print(int("42") + 1)
print(float("1.65") * 2)

Tengo 16 años
43
3.3

Preguntarle algo a quien usa el programa

En Colab, la función input muestra una pregunta, espera a que escribas la respuesta y la devuelve. Esto, en una celda de Colab, abre un recuadro para escribir:

nombre = input("¿Cómo te llamas? ")
print(f"Hola, {nombre}")

input siempre devuelve texto, aunque escribas un número. Si necesitas hacer cuentas con la respuesta, conviértela con int o float. En esta página no hay nadie que conteste, así que en los ejemplos vamos a guardar la respuesta directamente en una variable, como si la persona ya la hubiera escrito. En Colab, cambia esa línea por respuesta = input("¿Cuántos años tienes? ") y prueba.

# La respuesta llega como texto, igual que con input
respuesta = "15"
edad = int(respuesta)
print(f"El próximo año tendrás {edad + 1} años.")

El próximo año tendrás 16 años.

Primer proyecto: calculadora de IMC

El índice de masa corporal (IMC) relaciona el peso con la estatura: es el peso en kilogramos dividido entre la estatura en metros al cuadrado.

peso = 52        # en kilogramos
estatura = 1.60  # en metros
imc = peso / estatura ** 2
print(f"Tu IMC es {imc:.1f}")

Tu IMC es 20.3

Lo que va después de # es un comentario: Python lo ignora, y sirve para explicarle el código a quien lo lea (incluido tú, dentro de un mes). Fíjate en que no hacen falta paréntesis: ** se calcula antes que /. Para que tu calculadora pregunte los datos, en Colab cambia las dos primeras líneas por peso = float(input("Peso en kg: ")) y estatura = float(input("Estatura en m: ")).

Decisiones: if, elif y else

Un programa que siempre hace lo mismo sirve de poco. Para decidir, primero hay que comparar. Cada comparación da un bool, True o False:

Las comparaciones se combinan con and (las dos tienen que cumplirse), or (basta con una) y not (lo contrario). Supongamos que en un curso se aprueba con 51 sobre 100:

nota = 58
print(nota >= 51)
print(nota == 100)
print(nota != 100)
print(nota >= 51 and nota < 70)
print(not nota >= 51)

True
False
True
True
False

Con if (si), el programa ejecuta un bloque de líneas solo cuando la condición es True; con else (si no), ejecuta otro bloque cuando es False:

nota = 58
if nota >= 51:
    print("Aprobaste")
else:
    print("Todavía no apruebas")
print("Fin")

Aprobaste
Fin

Mira la forma: la condición termina con dos puntos, y las líneas que dependen de ella van sangradas, es decir, corridas 4 espacios a la derecha (Colab lo hace solo al pulsar Enter después de los dos puntos). La sangría no es decoración: es la manera en que Python sabe qué líneas están dentro del if. print("Fin") no tiene sangría, así que se ejecuta siempre. Si olvidas la sangría, Python se queja:

if nota >= 51:
print("Aprobaste")

  ...
    print("Aprobaste")
    ^
IndentationError: expected an indented block after 'if' statement on line 1

Cuando hay más de dos caminos, se usa elif («si no, si…»). Python revisa las condiciones de arriba abajo y ejecuta solo el bloque de la primera que se cumple. Así, la calculadora de IMC puede dar una categoría:

if imc < 18.5:
    categoria = "bajo peso"
elif imc < 25:
    categoria = "peso normal"
elif imc < 30:
    categoria = "sobrepeso"
else:
    categoria = "obesidad"
print(f"IMC {imc:.1f}: {categoria}")

IMC 20.3: peso normal

En el segundo elif no hace falta escribir imc >= 18.5 and imc < 25: si el programa llegó ahí, ya sabe que imc < 18.5 fue falso. Un aviso importante: estos cortes son los que se usan para adultos. En adolescentes que todavía están creciendo, el IMC se compara con tablas según la edad y el sexo, así que este programa es un ejercicio de código, no un diagnóstico.

Repetir: el bucle for

Para repetir algo, se usa un bucle. El bucle for recorre una serie de valores y ejecuta su bloque una vez por cada uno. range(5) da los números del 0 al 4: empieza en 0 y no incluye el 5.

for i in range(5):
    print("Vuelta", i)

Vuelta 0
Vuelta 1
Vuelta 2
Vuelta 3
Vuelta 4

range puede recibir dónde empezar, dónde parar (sin incluirlo) y de cuánto en cuánto avanzar. Para ver todos sus números de una vez, conviértelo en una lista con list:

print(list(range(1, 6)))
print(list(range(0, 20, 5)))
print(list(range(10, 0, -3)))

[1, 2, 3, 4, 5]
[0, 5, 10, 15]
[10, 7, 4, 1]

Con un for y una f-string, la tabla de multiplicar sale en tres líneas:

numero = 7
for i in range(1, 11):
    print(f"{numero} x {i} = {numero * i}")

7 x 1 = 7
7 x 2 = 14
7 x 3 = 21
7 x 4 = 28
7 x 5 = 35
7 x 6 = 42
7 x 7 = 49
7 x 8 = 56
7 x 9 = 63
7 x 10 = 70

Acumuladores: sumar dentro de un bucle

Volvamos a la actividad. Para sumar muchos números se usa un acumulador: una variable que empieza en 0 y a la que, en cada vuelta, se le suma algo. Este código es el programa de la actividad, con una línea más que imprime el valor de las variables en cada vuelta. Así puedes ver por dentro cualquier bucle:

total = 0
print("   n  total")
for n in range(1, 5):
    total = total + n
    print(f"{n:>4} {total:>6}")
print("Suma:", total)

   n  total
   1      1
   2      3
   3      6
   4     10
Suma: 10

El :>4 dentro de las llaves alinea el número a la derecha en un espacio de 4 caracteres, para que la tabla quede en columnas. Y ahora sí, la respuesta a la pregunta del principio:

total = 0
for n in range(1, 101):
    total = total + n
print(total)

5050

Repetir mientras: el bucle while

A veces no sabes cuántas vueltas hacen falta. El bucle while (mientras) repite su bloque mientras la condición sea True, y la revisa antes de cada vuelta. Si ahorras 15 bolivianos por semana, ¿cuántas semanas tardas en juntar 100?

ahorro = 0
semanas = 0
while ahorro < 100:
    ahorro = ahorro + 15
    semanas = semanas + 1
print(f"En {semanas} semanas juntas {ahorro} Bs.")

En 7 semanas juntas 105 Bs.

Algo dentro del bloque tiene que acercar la condición a False. Si olvidas la línea ahorro = ahorro + 15, el ahorro nunca cambia, la condición es True para siempre y el programa no termina: es un bucle infinito. En Colab lo detienes con el botón de detener de la celda (el mismo de reproducir, que mientras corre se convierte en un cuadrado) o con Entorno de ejecución → Interrumpir ejecución.

Un juego: adivina el número

El módulo random (aleatorio) viene con Python y sirve para sortear números. Un módulo es un conjunto de herramientas que se activa con import. random.randint(1, 20) da un número entero al azar entre 1 y 20, incluidos los dos.

Si cada vez que corres el programa sale un número distinto, nadie puede comprobar sus resultados. Por eso, en la ruta, todo programa con azar fija una semilla con random.seed: con la misma semilla, los «sorteos» salen siempre iguales. Para jugar de verdad, borra esa línea.

El juego: la computadora piensa un número y tú intentas adivinarlo; después de cada intento te dice si el secreto es más alto o más bajo. Aquí las respuestas del jugador están en una lista, varios valores entre corchetes separados por comas (en el tema 2 vas a trabajar mucho con ellas). intentos_jugador[0] es el primer valor de la lista, intentos_jugador[1] el segundo, y así: se cuenta desde 0.

import random

random.seed(7)
secreto = random.randint(1, 20)
# Lo que contesta el jugador, en orden
intentos_jugador = [10, 15, 12, 11]

intentos = 0
adivinado = False
while not adivinado:
    intento = intentos_jugador[intentos]
    intentos = intentos + 1
    if intento < secreto:
        print(f"{intento}: el secreto es más alto")
    elif intento > secreto:
        print(f"{intento}: el secreto es más bajo")
    else:
        print(f"{intento}: ¡correcto, en {intentos} intentos!")
        adivinado = True

10: el secreto es más alto
15: el secreto es más bajo
12: el secreto es más bajo
11: ¡correcto, en 4 intentos!

adivinado es un bool que hace de interruptor: empieza en False, y el bucle sigue mientras no se haya adivinado. En Colab, para jugar tú, cambia la línea intento = intentos_jugador[intentos] por esta, y borra random.seed(7) y la lista:

intento = int(input("Tu número: "))

Los errores son pistas

Equivocarse al programar es normal, incluso para quien lleva años haciéndolo. Lo que cambia con la práctica es la velocidad para leer el mensaje de error. Un mensaje tiene dos partes que importan:

1. La última línea: el tipo de error y una explicación corta. Empieza siempre por ahí.
2. La línea señalada: Colab marca con una flecha ----> o con un ^ la línea (o el lugar) donde Python se dio cuenta del problema. A veces el error de verdad está en la línea de arriba, por ejemplo un paréntesis que no se cerró.

Estos son los errores que más vas a ver al principio.

SyntaxError: el código no está bien escrito y Python ni siquiera empieza a ejecutarlo. Suele ser un paréntesis, una comilla o unos dos puntos que faltan.

print("Hola"

  ...
    print("Hola"
         ^
SyntaxError: '(' was never closed

IndentationError: falta o sobra sangría, como viste en el if.

NameError: usaste un nombre que Python no conoce. O la variable todavía no existe (la celda que la crea no se ejecutó), o la escribiste distinto (Edad en lugar de edad), o es un texto al que le faltan las comillas. Cuando el nombre se parece a uno que sí existe, Python a veces agrega una sugerencia al final: «Did you mean: …?» (¿quisiste decir…?).

print(puntaje)

Traceback (most recent call last):
  ...
----> 1 print(puntaje)

NameError: name 'puntaje' is not defined

TypeError: una operación con un tipo que no le corresponde, como sumar un texto y un número.

ValueError: el tipo es correcto, pero el valor no sirve. int sabe convertir "15", pero no "quince":

edad = int("quince")

Traceback (most recent call last):
  ...
----> 1 edad = int("quince")

ValueError: invalid literal for int() with base 10: 'quince'

Y los más difíciles: los errores sin mensaje. El programa corre, pero hace otra cosa de la que querías (sumar en lugar de multiplicar, un range que se queda corto, un acumulador que vuelve a 0 en cada vuelta). Para encontrarlos sirve lo de la actividad: imprimir las variables en cada paso y comparar con lo que esperabas.

Una regla hecha a mano

Con lo que ya sabes puedes escribir un programa que «decide» como una persona. Este da un consejo de ropa según la temperatura de cada día:

temperaturas = [3, 11, 17, 24, 8]
for t in temperaturas:
    if t < 10:
        consejo = "lleva chamarra"
    elif t < 20:
        consejo = "lleva una chompa"
    else:
        consejo = "ropa ligera"
    print(f"{t:>2} °C: {consejo}")

 3 °C: lleva chamarra
11 °C: lleva una chompa
17 °C: lleva una chompa
24 °C: ropa ligera
 8 °C: lleva chamarra

Funciona, pero hazte una pregunta: ¿quién decidió que el corte va en 10 grados y no en 12? Una persona, a ojo. Este programa es un clasificador: recibe un dato y lo pone en una categoría. Sus reglas las escribió alguien que pensó en el problema.

La inteligencia artificial que vas a aprender en esta ruta da vuelta esa idea: en lugar de escribir las reglas, le das a la computadora muchos ejemplos con su respuesta correcta y ella encuentra sola los números de la regla. En el tema 6 eso va a ser una recta que se ajusta a los datos; en el tema 11, un árbol de decisión que elige solo sus cortes, como el «menos de 10 grados» de aquí. Pero por dentro, todo eso sigue siendo variables, decisiones y bucles.

Lo que aprendiste y lo que sigue

• Un programa es una lista de instrucciones que la computadora ejecuta una por una y en orden. En un cuaderno de Colab, cada celda se ejecuta cuando tú lo pides y el cuaderno recuerda las variables entre celdas.
• Cada valor tiene un tipo: int, float, str o bool. Una variable es una caja con nombre; = guarda en ella un valor nuevo y el anterior se pierde.
• print y las f-strings muestran resultados; int, float y str convierten entre tipos, y input siempre devuelve texto.
• if, elif y else eligen un camino según una condición. La sangría marca qué líneas están dentro.
• for repite una vez por cada valor (por ejemplo, de un range); while repite mientras una condición se cumpla. Un acumulador junta un resultado vuelta a vuelta.
• Un mensaje de error se lee desde la última línea: el tipo de error dice qué buscar y la flecha, dónde.

En el tema 2 vas a organizar el código en funciones que puedes reutilizar y a guardar muchos datos en listas y diccionarios.