Python desde cero

Piensa en cómo le explicarías a alguien que nunca ha hecho un sándwich cómo hacerlo. «Pon el jamón» no sirve si antes no dijiste «saca el pan». Esa lista de pasos, exactos y en orden, se llama algoritmo. En el juego «Prográmame» lo viviste: el maestro hace solo lo que le dicen, y por eso se atora.

Una computadora es igual de obediente y de literal. Programar es escribir el algoritmo en un idioma que la máquina entienda. Ese idioma es un lenguaje de programación, y el que vamos a usar se llama Python: se lee casi como inglés y se usa en todo, desde videojuegos hasta robots.

Tu primer programa tiene una sola orden: print («imprime», o sea «muestra en pantalla»). Lo que va entre comillas es el texto que quieres mostrar.

print("Hola")

Sale:

Hola

Si pones varias órdenes, Python las hace una por una, de arriba abajo. Nunca se salta una ni cambia el orden.

print("Saca el pan")
print("Unta la mayonesa")
print("Pon el jamón")

Sale:

Saca el pan
Unta la mayonesa
Pon el jamón

Como la máquina es tan literal, hasta una letra importa. Estos cuatro programas parecen casi iguales al de arriba y ninguno funciona:

A esos se les llama errores de dedo. Le pasan a todos los programadores, todos los días. Lo importante no es no cometerlos nunca: es saber leer el mensaje que te da Python para encontrarlos (eso lo vemos en la última lección).

El error más caro de un programador que empieza no es de sintaxis: es empezar a teclear sin saber qué va a hacer el programa. La cura se llama pseudocódigo: los pasos escritos en español, numerados, sin preocuparse por los puntos ni los paréntesis.

Quiero un programa que diga si alguien puede entrar a una función de cine para mayores de 15. En pseudocódigo:

1. Preguntar la edad
2. Si la edad es 15 o más
       decir "puedes pasar"
   Si no
       decir "no puedes pasar"

Y ahora, traducido a Python casi palabra por palabra:

edad = int(input("¿Cuántos años tienes? "))
if edad >= 15:
    print("puedes pasar")
else:
    print("no puedes pasar")

Las tres palabras que hacen falta para escribir cualquier pseudocódigo:

El diagrama de flujo es el mismo plan pero dibujado, y tiene tres figuras que conviene reconocer porque se usan en todos lados:

• Óvalo: inicio y fin.
• Rectángulo: un paso que se hace (calcular, imprimir, guardar).
• Rombo: una decisión, con dos salidas: sí y no.

Lo útil del rombo es que te obliga a contestar qué pasa por cada salida. Casi todos los programas que «a veces no funcionan» son programas a los que les falta una de las dos salidas del rombo.

Cómo se usa de verdad. Escribe el pseudocódigo en el cuaderno. Luego traduce una línea a la vez y corre el programa cada dos o tres líneas, para que si algo truena sepas exactamente qué fue lo último que escribiste.

Un programa necesita recordar cosas: el puntaje, el nombre del jugador, cuántas vidas quedan. Para eso usa variables: cajas con nombre donde guardas un valor. Para crear una escribes el nombre, el signo = y lo que quieres guardar.

edad = 12
nombre = "Ana"

Desde ese momento, cada vez que escribes edad, Python va a la caja y saca el 12. Fíjate en la diferencia: sin comillas usa la caja; con comillas es solo la palabra.

edad = 12
print(edad)
print("edad")

Sale:

12
edad

Por eso una caja puede cambiar de valor, y por eso tiene sentido esta línea que en matemáticas sería imposible:

x = 5
x = x + 1
print(x)

Sale:

6

Léela así: «toma lo que hay en x (5), súmale 1 (6) y guarda el resultado en x». La caja tenía 5; ahora tiene 6. El valor viejo se pierde.

Para seguir un programa con variables conviene hacer una tabla de seguimiento: un renglón por línea, y qué queda en cada caja después de esa línea.

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

Nombres válidos. Un nombre lleva letras, números y guion bajo, sin espacios ni acentos, y no puede empezar con número: edad, mi_edad, puntos2 sí; 2puntos, mi edad, mi-edad no. Mayúsculas y minúsculas son distintas: Edad y edad son dos cajas diferentes. Y un buen nombre dice qué guarda: precio es mejor que p.

No todos los valores son iguales para Python. Hay cuatro tipos que vas a usar todo el tiempo:

Para saber de qué tipo es algo, se lo preguntas a Python con type():

print(type(12))
print(type(3.5))
print(type("Hola"))
print(type(True))

Sale:

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

Lo que más confunde: las comillas convierten cualquier cosa en texto, aunque adentro haya un número. "3" no es el número 3: es el dibujo de un 3. Y con texto, el signo + no suma: pega.

print(3 + 4)
print("3" + "4")
print("Hola" + " " + "Ana")
print("ja" * 3)

Sale:

7
34
Hola Ana
jajaja

Cuando tienes un dato del tipo equivocado, lo conviertes: int("3") vuelve el texto "3" en el número 3; str(5) vuelve el número 5 en el texto "5"; float("2.5") da el decimal 2.5.

print(int("3") + int("4"))
print(str(5) + "0")
print(float("2.5") + 1)

Sale:

7
50
3.5

En el juego «Fábrica de palabras» hiciste justo esto: pegar, repetir y recortar textos. Y en «Calculadora de código» viste que la calculadora se queja si le das un texto donde iba un número.

Python es una calculadora muy obediente. Estas son sus operaciones con números:

Ojo con la división: 6 / 2 no da 3, da 3.0 (un float). Si quieres el entero, usas 6 // 2. Y % es el residuo de la casita: por eso n % 2 == 0 dice si n es par.

La jerarquía es la misma que en matemáticas: primero paréntesis, luego potencias, luego multiplicar, dividir, // y %, y al final sumar y restar. De izquierda a derecha cuando empatan.

print(2 + 3 * 4)
print((2 + 3) * 4)
print(20 - 2 ** 3)

Sale:

14
20
12

Ahora lo nuevo: pedirle algo al usuario con input(). Lo que va entre paréntesis es la pregunta que se muestra; lo que la persona escriba se guarda en la variable.

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

Sale (si escribes Ana):

¿Cómo te llamas? Ana
Hola, Ana

edad = int(input("¿Cuántos años tienes? "))
print("El año que entra tendrás", edad + 1)

Sale (si escribes 12):

¿Cuántos años tienes? 12
El año que entra tendrás 13

Sin el int(), edad + 1 sería "12" + 1: texto más número, TypeError. Fíjate también que print acepta varias cosas separadas por coma y les pone un espacio entre ellas.

Hay una forma más cómoda de mezclar texto con variables: la f-string. Pones una f antes de las comillas y, adentro, las variables entre llaves. Python las sustituye por su valor (y hasta hace cuentas adentro).

edad = 12
print(f"Tienes {edad} años y en 5 años tendrás {edad + 5}")

Sale:

Tienes 12 años y en 5 años tendrás 17

Hasta ahora los programas hacen siempre lo mismo. Un if («si») les permite decidir: hace una pregunta, y según la respuesta hace una cosa u otra.

edad = 15
if edad >= 12:
    print("Puedes entrar")
else:
    print("Todavía no")

Sale:

Puedes entrar

Mira la forma: la pregunta termina en dos puntos, y lo que depende de ella va un escalón adentro (4 espacios). A eso se le llama sangría. El else («si no») es lo que pasa cuando la pregunta sale falsa; es opcional.

Las preguntas se hacen con comparaciones, que siempre dan True o False:

Ojo: == (dos signos) pregunta si es igual; = (uno) guarda en una caja. Son cosas distintas.

Cuando hay más de dos caminos, usas elif («si no, pero si…»). Python revisa las preguntas de arriba abajo y entra en la primera que sea verdadera; las demás ya no las mira.

calif = 8
if calif >= 9:
    print("Excelente")
elif calif >= 6:
    print("Aprobado")
else:
    print("A estudiar")

Sale:

Aprobado

Puedes juntar preguntas con and (las dos tienen que ser verdaderas), or (basta una) y not (voltea la respuesta). Es lo mismo que el «y», «o» y «no» del curso de Lógica.

edad = 14
if edad >= 12 and edad <= 15:
    print("Eres de secundaria")

Para saber qué hace un programa con if, sigue las líneas con la mano, en una tabla: qué vale cada variable, si cada pregunta sale verdadera o falsa, y por dónde se va.

En «Atrapa el bucle» encontraste lo que se repetía y lo escribiste una sola vez. En Python eso se hace con for:

for i in range(5):
    print("Hola")

Sale:

Hola
Hola
Hola
Hola
Hola

Léelo así: «para cada i en el rango de 5, haz lo de adentro». Lo de adentro, igual que en el if, va con sangría y dos puntos antes. La variable i es el contador de vueltas, y vale algo distinto en cada una:

for i in range(5):
    print(i)

Sale:

0
1
2
3
4

Si quieres empezar en otro número, le das inicio y fin: range(1, 6) es 1, 2, 3, 4, 5 (el 6 no entra). Y con un tercer número das el paso: range(2, 11, 2) es 2, 4, 6, 8, 10.

for i in range(1, 4):
    print(f"Vuelta {i}")

Sale:

Vuelta 1
Vuelta 2
Vuelta 3

Lo más útil de un bucle es acumular: ir sumando en una caja vuelta tras vuelta. La caja se crea antes del bucle, en 0, y cada vuelta le agrega algo. Para no perderte, haz la tabla de seguimiento con una columna por variable:

suma = 0
for i in range(1, 5):
    suma = suma + i
print(suma)

Sale:

10

Y la tortuga de «El tortugito» es puro for. Un cuadrado son cuatro veces «avanza y gira 90°»:

import turtle
t = turtle.Turtle()
for i in range(4):
    t.forward(100)
    t.left(90)

Las dos líneas con sangría se repiten juntas, cuatro veces. Con range(3) y left(120) sale un triángulo; con range(6) y left(60), un hexágono. El giro siempre es 360 entre el número de lados.

El for sirve cuando sabes cuántas vueltas quieres. Pero a veces no lo sabes: «pregunta hasta que acierte», «resta hasta que se acabe». Para eso está while («mientras»): repite lo de adentro mientras la condición sea verdadera, y la revisa antes de cada vuelta.

x = 1
while x <= 3:
    print(x)
    x = x + 1
print("Fin")

Sale:

1
2
3
Fin

La variable que se revisa en la condición se llama contador. Fíjate en la línea x = x + 1: es la que mueve al contador. Sin ella, pasa esto:

x = 1
while x <= 3:
    print(x)

Sale:

1
1
1
1
… (nunca termina)

Es un bucle infinito: x siempre vale 1, la condición siempre es verdadera, y el programa se queda imprimiendo unos para siempre. Si te pasa, lo detienes con Ctrl + C.

A veces quieres salir del bucle a la mitad, sin esperar la condición. Para eso está break («rompe»): sale del bucle en ese instante. Es común con while True: (una condición que siempre es verdadera) y un if adentro que decide cuándo parar.

while True:
    r = input("¿Seguimos? ")
    if r == "no":
        break
print("Adiós")

Pregunta y pregunta; en cuanto escribes «no», el break lo saca y sale «Adiós».

¿for o while? Si sabes cuántas veces (10 vueltas, cada elemento de una lista): for. Si es hasta que pase algo (que acierte, que se acabe el dinero, que escriba «salir»): while.

Un bucle se puede copiar sin entenderlo. La prueba de que lo entiendes es poder decir, sin correr el programa, qué valor tiene cada variable en cada vuelta. Para eso está la tabla de rastreo: una columna por variable y un renglón por vuelta.

total = 0
for i in range(1, 5):
    total = total + i
print(total)

Se sigue a mano, anotando antes y después de cada vuelta:

El programa imprime 10, y ahora sabes por qué. Fíjate en dos cosas que la tabla deja ver y el código no: que range(1, 5) da cuatro vueltas (el 5 no entra) y que total se va acumulando en lugar de empezar de cero cada vez.

Cómo se hace, paso a paso:

1. Apunta las variables que hay, cada una en su columna, con su valor inicial.
2. Entra a la primera vuelta y escribe el valor de la variable del bucle.
3. Ejecuta cada línea de adentro, en orden, cambiando los valores que toquen.
4. Al final de la vuelta, revisa la condición: ¿hay otra vuelta?
5. Cuando se acaba, la última línea de la tabla es lo que va a imprimir.

Con un while es igual, pero hay que apuntar la condición, porque ahí es donde se cuelgan los programas:

vidas = 3
while vidas > 0:
    print("Te quedan", vidas)
    vidas = vidas - 1

Si en ese programa borras la línea vidas = vidas - 1, la condición nunca se vuelve falsa y el programa no se detiene nunca. La tabla lo caza al tercer renglón, cuando ves que la columna de vidas no se mueve.

Si quieres guardar las calificaciones de 30 alumnos, no vas a hacer 30 variables. Para eso existe la lista: una caja con varios compartimentos, en orden. Se escribe entre corchetes, con los valores separados por coma.

frutas = ["manzana", "pera", "uva"]
print(frutas[0])
print(frutas[2])
print(len(frutas))

Sale:

manzana
uva
3

Cada compartimento tiene un número que se llama índice, y empieza en 0: el primero es [0], el segundo [1], el tercero [2]. len() dice cuántos elementos hay.

Hay un atajo para el último: [-1]. Y [-2] es el penúltimo. Así no tienes que saber cuántos hay.

Para agregar al final se usa append, y para recorrer la lista completa, un for que va tomando los elementos uno por uno (sin range: directamente «para cada fruta en frutas»):

frutas.append("mango")
print(frutas[-1])
for f in frutas:
    print("Me gusta la " + f)

Sale:

mango
Me gusta la manzana
Me gusta la pera
Me gusta la uva
Me gusta la mango

Las listas también guardan números, y con un for se acumulan igual que en la lección anterior. Y para buscar si algo está, se usa in:

califs = [8, 10, 7]
total = 0
for c in califs:
    total = total + c
print(total)
print(10 in califs)

Sale:

25
True

Si en «El tortugito» dibujaste tres cuadrados, escribiste el mismo bucle tres veces. Una función evita eso: le pones nombre a un pedazo de programa y luego lo llamas por su nombre cuantas veces quieras.

def saluda(nombre):
    print("Hola, " + nombre)

saluda("Ana")
saluda("Beto")

Sale:

Hola, Ana
Hola, Beto

Las partes: def («define») avisa que viene una función; saluda es su nombre; lo que va entre paréntesis, nombre, es el parámetro: una caja que se llena con lo que le mandes al llamarla. El cuerpo va con sangría, como el if y el for. Y saluda("Ana") es la llamada: mete "Ana" en la caja nombre y ejecuta el cuerpo.

Muchas funciones no muestran nada: calculan y devuelven un resultado con return, para que lo uses donde quieras: guardarlo en una variable, imprimirlo, meterlo en otra cuenta.

def doble(x):
    return x * 2

y = doble(4)
print(y)
print(doble(10) + 1)

Sale:

8
21

Una función puede tener varios parámetros, separados por coma. Al llamarla, los valores entran en el mismo orden:

def area(base, altura):
    return base * altura

print(area(5, 3))
print(area(10, 2))

Sale:

15
20

Una idea importante: las variables que creas dentro de una función solo existen adentro. Si en area hicieras resultado = base * altura, afuera no podrías usar resultado: es una caja de adentro. Lo que quieras sacar, lo sacas con return.

Y la tortuga, con función: def cuadrado(lado): con el for de 4 vueltas adentro, y luego cuadrado(50), cuadrado(100), cuadrado(150). Tres cuadrados de distinto tamaño, un solo bucle escrito.

Todos los programas fallan al principio. La diferencia entre quien programa y quien se frustra es que el primero lee el mensaje. Mira uno completo:

Traceback (most recent call last):
  File "juego.py", line 2, in <module>
    print(puntaje)
NameError: name 'puntaje' is not defined

Parece mucho, pero solo importan dos cosas: line 2 (en qué línea se atoró) y el último renglón: el tipo de error y una pista. «NameError: name puntaje is not defined» = «no conozco ninguna caja llamada puntaje». Vas a la línea 2 y ves que escribiste puntaje donde la caja se llamaba puntos.

Estos son los cuatro que vas a ver todo el tiempo, con sus causas:

Hay otros dos que también verás: IndexError (pediste un lugar de la lista que no existe) y ZeroDivisionError (dividiste entre 0). Los nombres dicen lo que pasó: con el tiempo los lees como palabras normales.

Cuando el programa no explota pero da un resultado raro, la herramienta es probar con prints: pones print(variable) en varios puntos para ver qué valor lleva cada caja, y así descubres en qué línea se descompuso. Es lo mismo que la tabla de seguimiento, pero la hace Python por ti.

total = 0
for i in range(1, 4):
    total = total + i
    print("vuelta", i, "total", total)
print(total)

Sale:

vuelta 1 total 1
vuelta 2 total 3
vuelta 3 total 6
6

Si esperabas 10 y ves que la última vuelta es la 3, ya sabes: te faltó una vuelta, el range debía llegar a 5. Cuando lo arreglas, quitas el print de prueba.

Hay dos clases de errores. Los de la lección anterior hacen que el programa truene, y el mensaje te dice la línea. Los peores son los otros: el programa corre bien y da un resultado equivocado, sin decir nada.

Para ésos hay un método, y es el mismo de «adivina el número»: partir por la mitad.

1. Busca un caso donde falle y que puedas calcular a mano. Si no sabes cuál es la respuesta correcta, no puedes depurar.
2. Pon un print a la mitad del programa, mostrando las variables importantes.
3. Corre y compara con lo que debería valer ahí.
4. Si ahí ya está mal, el error está antes; si está bien, está después.
5. Repite en la mitad que quedó, hasta que el error quepa en una línea.

Ejemplo. Este programa debería dar el promedio de 10 y 20, o sea 15, y da 20:

a = 10
b = 20
suma = a + b
promedio = suma / a
print(promedio)

Pongo un print a la mitad, después de la suma: print("suma:", suma). Sale 30, que es lo correcto, así que el error está después de esa línea. Y ahí está: dice suma / a en lugar de suma / 2.

Las tres preguntas de un programa que da mal, en orden:

Dos reglas de oro para no enredarte más:

• Un cambio, una prueba. Si cambias tres cosas y funciona, no sabes qué era; si deja de funcionar, tampoco.
• Quita los prints de depuración al final. No son parte del programa, son tus andamios.

El caso más común de todos. El programa da mal porque la variable no empezó donde debía: un total que no se puso en 0, o que se pone en 0 adentro del bucle y se borra en cada vuelta. La tabla de rastreo de la lección anterior y un print en la primera vuelta lo cazan en diez segundos.

En el curso de estadística aprendes que la probabilidad de sacar un 3 con un dado es 16. Eso quiere decir que a la larga sale una de cada seis veces. Pero «a la larga» no se puede ver tirando un dado veinte veces… y sí se puede ver con un programa.

Python trae una caja de herramientas para el azar que se llama random:

import random
dado = random.randint(1, 6)
print(dado)

random.randint(1, 6) da un número al azar del 1 al 6, los dos incluidos. Ahora lo tiramos diez mil veces y contamos cuántos 3 salen:

import random
treses = 0
for i in range(10000):
    if random.randint(1, 6) == 3:
        treses = treses + 1
print(treses)

Lo esperado es 10 000 ÷ 6 = 1 666 y algo. Al correrlo sale algo como 1 648, o 1 702: cerca, pero nunca exacto. Y si lo corres otra vez sale otro número parecido. Eso es la probabilidad: no una promesa, una tendencia.

Lo que se puede responder simulando y es un dolor de cabeza calculando:

• ¿Qué suma sale más seguido con dos dados? Tira dos dados diez mil veces y cuenta. Sale el 7, porque es la suma que se puede armar de más maneras.
• ¿Cuántas veces hay que tirar una moneda para sacar tres águilas seguidas? Es una pregunta difícil con lápiz y fácil simulando.
• ¿Cuánta gente hace falta en un salón para que dos cumplan el mismo día? Con 23 personas ya es más probable que sí: suena imposible, y la simulación lo confirma.

Las dos herramientas del azar que vas a usar:

Lo honesto de una simulación. Da un resultado aproximado, así que se reporta redondo: «salió como 1 670 de 10 000, o sea cerca de 16». Si la simulación y la cuenta teórica se alejan mucho, hay un error: en el programa o en la cuenta. Las dos se revisan entre ellas, y eso es lo que la hace valiosa.