Podcast sobre Introducción a la Programación en Python

Kapitoly

El código detrás de tu día a día

El reto del cajero automático

Bucles: la herramienta clave

Rúbrica del Primer Ejercicio

Depurando el Código Primo

Criptografía por Sustitución

Decodificando con Python

Manejando Mensajes Corruptos

Texto vs. Números

La Magia de la Conversión

Tipos de Operadores

Comparando Valores

La Magia del "IF"

El Espacio que Importa: Indentación

El Plan B: Usando "ELSE"

Pregunta de Cálculo y Código

Pregunta de Lógica Pura

Introducción al Módulo 'time'

Obteniendo la Hora

Pausando la Ejecución

Creando y usando listas

Métodos para manipular listas

Resumen y despedida

Přepis

Alba: ¿Alguna vez te has equivocado poniendo la contraseña de tu móvil tres veces y... se ha bloqueado? O cuando un juego te da un número limitado de vidas. Bueno, la lógica que hay detrás de eso se programa, y a menudo, se hace con Python.

Álvaro: Exactamente. Esos pequeños dramas cotidianos están controlados por algoritmos muy simples. Son las reglas del juego, por así decirlo.

Alba: Y entender esas reglas es clave para empezar a programar. Estás escuchando Studyfi Podcast, donde desglosamos los temas complejos para que puedas arrasar en tus exámenes.

Álvaro: Hoy vamos a ver cómo pasar de la teoría de Python a la práctica con algunos ejercicios clásicos que te podrías encontrar.

Alba: Vale, empecemos con uno muy típico: simular la solicitud de clave en un cajero automático. Tienes tres intentos. Si fallas, la tarjeta es "retenida". Si aciertas, ¡bienvenido!

Álvaro: ¡Me encanta este ejemplo! Es perfecto. Aquí la clave es usar un bucle y un contador. Necesitamos una variable para la clave correcta, digamos 1234, y otra para contar los intentos, que empieza en cero.

Alba: ¿Y cómo controlas los tres intentos?

Álvaro: Con un bucle while. Mientras el número de intentos sea menor que tres, el programa te seguirá pidiendo la clave. Si la clave que introduces es correcta, muestras el mensaje de bienvenida y sales del bucle. ¡Fácil!

Alba: ¿Y si me equivoco las tres veces?

Álvaro: Si te equivocas, sumas uno al contador de intentos. Si el contador llega a tres y nunca acertaste, el bucle termina y ¡zas! Muestras el mensaje de "Tarjeta retenida".

Alba: Pobre de mi tarjeta. Suena lógico. El bucle while es como un portero insistente.

Álvaro: Totalmente. Y es la herramienta perfecta cuando no sabes cuántas veces se va a ejecutar algo. El usuario podría acertar a la primera o a la tercera. El while es flexible.

Alba: ¿Y qué pasa con el bucle for? ¿Cuándo lo usaríamos?

Álvaro: El for es ideal cuando SÍ sabes el número exacto de repeticiones. Por ejemplo, si el problema es "mostrar los primeros 20 números pares". Sabes que son exactamente 20, así que un for que vaya de 1 a 20 es mucho más directo.

Alba: Entendido. while para la incertidumbre y for para la certeza. ¡Es una buena regla!

Álvaro: Justo. Dominar estos dos bucles te abre la puerta a resolver una cantidad enorme de problemas. Son el pan de cada día de la programación.

Alba: ...y una vez que tenemos los cálculos, ¿cómo se evalúa que el código está realmente bien hecho? No es solo que funcione, ¿verdad?

Álvaro: Exacto, Alba. No basta con que "corra". Hay una rúbrica, un desglose de puntos. Pensemos en el primer problema, el de sumar boletas.

Alba: ¡Ah, sí! El que calculaba el IVA y el monto final para el negocio.

Álvaro: Ese mismo. Primero, se evalúa la inicialización. ¿Creaste la variable para la suma en cero? ¿Pediste el número de boletas y lo convertiste a entero con int()? Eso ya te da unos puntos.

Alba: Entiendo. ¿Y el ciclo para pedir los valores?

Álvaro: Aquí es donde muchos tropiezan. Usar un for es lo ideal. Si usas while, es fácil equivocarse en los límites... como empezar en 1 en vez de 0. Es un error clásico que resta puntos.

Alba: Suena a algo que yo haría, definitivamente.

Álvaro: A todos nos ha pasado. Luego, dentro del ciclo, es clave sumar correctamente. Y al final, usar print para mostrar todo claramente. Ahí se revisa que sepas calcular el 19% de IVA, por ejemplo.

Alba: Vale, eso para el primer ejercicio. ¿Y qué hay del segundo, el de depurar el número primo? Ese código era un desastre.

Álvaro: Era un buen rompecabezas. La rúbrica ahí evalúa tu capacidad de análisis. Primero, te pide justificar por qué falla con números como el 1 y el 4.

Alba: Claro, para ver si entiendes el flujo del error antes de intentar arreglarlo.

Álvaro: Exacto. El verdadero reto es reescribirlo. Hay que corregir la inicialización de la variable verificarPrimo y, lo más importante, la lógica dentro del while.

Alba: ¿Te refieres a la condición del if que revisa si el número es divisible?

Álvaro: ¡Justo eso! Tienes que asegurarte de que cambie el estado de verificarPrimo correctamente. Un pequeño error ahí... y de repente todos los números parecen primos.

Alba: El paraíso de los números.

Álvaro: Básicamente. Arreglando eso, tienes casi todo el puntaje. Ahora, hablando de lógica y de cómo tomar decisiones en el código...

Alba: ...así que usar bucles para recorrer listas es súper potente. Pero, Álvaro, ¿podemos usar esto para algo más... secreto? ¿Como mensajes para espías?

Álvaro: ¡Absolutamente! De hecho, nos lleva directamente al fascinante mundo de la criptografía. Pensemos en el método más básico para empezar.

Alba: ¿Criptografía? Suena a algo muy complicado.

Álvaro: Para nada. Imagina que en lugar de letras, usamos números. Por ejemplo, la palabra “hola” se podría convertir en la secuencia de números 7, 14, 11, 0.

Alba: A ver, déjame adivinar... La 'h' es la octava letra del alfabeto, pero como en programación empezamos a contar desde cero, su índice es 7. ¿Es así?

Álvaro: ¡Exacto! Y lo mismo con las demás. La 'o' es el índice 14, la 'l' es el 11 y la 'a', al ser la primera, es el índice 0. Es un cifrado por sustitución muy simple.

Alba: Vale, lo pillo. Entonces, si nos dan una lista de números, ¿cómo lo programamos para descifrar el mensaje?

Álvaro: Es bastante directo. Necesitamos dos listas. Una que llamaremos “alfabeto”, con las letras de la 'a' a la 'z' y un espacio al final. Y otra lista, “msje”, con nuestros números secretos.

Alba: ¡Me siento como una agente secreta!

Álvaro: ¡Prepárate, agente Alba! Lo que hacemos es recorrer cada número en la lista “msje” y usarlo como índice para buscar la letra correspondiente en la lista “alfabeto”.

Alba: Entendido. Pero... ¿qué pasa si un número en el mensaje está mal? Por ejemplo, un 50. ¡No hay 50 letras en nuestro alfabeto!

Álvaro: ¡Excelente pregunta! Y es la clave de este problema. Si encontramos un número que está fuera del rango de nuestra lista “alfabeto”, el programa debe detenerse inmediatamente.

Alba: ¿Así, sin más?

Álvaro: Sí. Detiene la ejecución y muestra solo el mensaje que ha logrado descifrar hasta ese momento. Por ejemplo, si el mensaje era “Vamos por” seguido de un 50, en la pantalla solo veríamos “Vamos por”.

Alba: ¡Es como un mensaje que se autodestruye si está corrupto! Me encanta.

Álvaro: Exactamente. Es una forma muy simple pero efectiva de manejar errores. La idea clave es siempre validar tus datos antes de usarlos.

Alba: Genial. Entonces, un bucle, la indexación y una condición if para validar son las herramientas clave. Esto me da una idea para nuestro siguiente reto...

Alba: ...así que básicamente, una variable es como una caja con una etiqueta donde guardamos datos. ¡Entendido!

Álvaro: Exacto. Y justo como en la vida real, no todas las cajas son para lo mismo. No guardarías sopa en una caja de zapatos, ¿verdad?

Alba: Espero que no. Me imagino que con Python pasa algo parecido.

Álvaro: Justamente. En programación, es crucial distinguir entre tipos de datos. Pensemos en los dos más básicos: texto y números.

Alba: Ok, como la palabra "hola" y el número 10.

Álvaro: Precisamente. Al texto lo llamamos 'string' o cadena. Y aquí viene lo importante... para Python, el texto "3.14" entre comillas no es lo mismo que el número 3.14 sin comillas.

Alba: Espera, ¿cómo? Se ven casi iguales. ¿Por qué le importa tanto al computador?

Álvaro: Piénsalo así: al texto "3.14" no puedes restarle 1. Sería como intentar restarle 1 a la palabra "gato". No tiene sentido. Pero al número 3.14, claro que puedes restarle 1 y obtener 2.14.

Alba: Ah, ya veo. El texto es solo un dibujo de los números, no el valor matemático en sí.

Álvaro: ¡Esa es una forma genial de verlo! Son solo símbolos. Y aquí es donde muchos principiantes se tropiezan, especialmente con una función que usamos todo el tiempo: input().

Alba: La función input(), la que usamos para pedirle datos al usuario, ¿cierto?

Álvaro: La misma. Y aquí está el truco: input() siempre, siempre, SIEMPRE guarda lo que el usuario escribe como si fuera texto. Sin excepciones.

Alba: ¿Incluso si escribo mi año de nacimiento? ¿Lo guarda como texto?

Álvaro: ¡Sí! Y eso causa problemas. Imagina que hacemos un pequeño programa para calcular la edad. Pides el año de nacimiento con input() y luego intentas restarlo del año actual, digamos 2024.

Alba: ¡Claro! Estaría intentando hacer 2024 - "2001". ¡Una resta entre un número y un texto! Python se va a quejar.

Álvaro: Se va a quejar mucho. Te dará un error. Por suerte, la solución es súper fácil. Tenemos unas funciones mágicas para convertir tipos de datos.

Alba: ¿Funciones mágicas? Suena bien.

Álvaro: Son int() y float(). Si le pasas un texto que parece un número entero a la función int(), te devuelve el número de verdad. Por ejemplo, int("2001") te da el número 2001.

Alba: Y supongo que float() hace lo mismo pero para números con decimales, como nuestro "3.14".

Álvaro: ¡Exacto! Entonces, el código correcto sería: primero pides el dato con nacimientoTexto = input(). Y en la siguiente línea, lo conviertes con nacimientoNumero = int(nacimientoTexto). Ahora sí puedes hacer la resta sin problemas.

Alba: Oye, y he visto que a veces la gente lo hace todo en una línea, algo como nacimiento = int(input()). ¿Es lo mismo?

Álvaro: Es exactamente lo mismo. Es solo una forma más compacta y eficiente de escribirlo. Primero se ejecuta lo de adentro, input(), y el resultado (el texto) se le pasa directamente a int() para que lo convierta.

Alba: Genial. Entonces, una vez que tenemos los datos en el formato correcto, podemos empezar a operar con ellos. ¿Qué tipo de operaciones podemos hacer?

Álvaro: Hay tres grandes grupos de operadores que usamos constantemente. El primero es el más simple: el operador de asignación.

Alba: El símbolo de igual: =. Lo hemos estado usando todo el tiempo.

Álvaro: Ese mismo. Su única misión es tomar el valor de la derecha y guardarlo en la variable de la izquierda. Simple, pero fundamental. Funciona de derecha a izquierda.

Alba: Ok, fácil. ¿Cuál es el segundo grupo?

Álvaro: Los operadores algebraico-lógicos. Aquí es donde está la acción. Son los que ya conoces de matemáticas: suma (+), resta (-), multiplicación (*) y división (/).

Alba: Los clásicos. ¿Hay alguno más exótico en Python?

Álvaro: ¡Claro! Tenemos, por ejemplo, el módulo (%), que te da el resto de una división. También la división entera (//), que te da el resultado sin decimales. Y la potencia (**), para elevar un número a otro.

Alba: Vaya, la computadora es básicamente una supercalculadora. ¿Y la parte 'lógica' de esos operadores?

Álvaro: Ah, eso se refiere a operadores como and, or y not. Estos no trabajan con números, sino con valores booleanos: verdadero o falso. Pero esa es una madriguera de conejo para otro momento.

Alba: De acuerdo. Me queda el tercer grupo de operadores.

Álvaro: Son los operadores relacionales o de comparación. Su trabajo es comparar dos valores y decirnos si la comparación es verdadera o falsa.

Alba: ¿Te refieres a mayor que (>), menor que (<)... ese tipo de cosas?

Álvaro: Sí, y también algunos muy importantes en programación: igual a, que se escribe con dos iguales ==, y distinto de, que es !=.

Alba: ¿Por qué dos iguales para comparar? ¿No basta con uno?

Álvaro: ¡Excelente pregunta! Es para no confundirlo con el operador de asignación. Recuerda, un solo = guarda un valor. Dos == preguntan: "Oye, ¿estas dos cosas son iguales?". La respuesta siempre será True o False.

Alba: Tiene todo el sentido. Un = es una orden, y == es una pregunta.

Álvaro: ¡Me encanta esa analogía! Es perfecta. Y esa simple pregunta, esa capacidad de comparar y obtener un True o un False, es la base de toda la toma de decisiones en un programa.

Alba: Supongo que nos lleva a cómo hacer que el programa actúe diferente según esas respuestas, ¿no? Con estructuras como los if.

Álvaro: Vas un paso por delante. Exactamente. Esas comparaciones son el motor de las estructuras de control, que es justo de lo que hablaremos a continuación.

Alba: Y justo así, con esas variables que vimos, podemos guardar todo tipo de datos. Pero... ¿cómo hacemos que el programa reaccione a esos datos? O sea, que tome decisiones.

Álvaro: ¡Exactamente! Esa es la pregunta clave, Alba. Y nos lleva directamente a una de las ideas más poderosas de la programación: las estructuras condicionales.

Alba: Suena a algo muy técnico. ¿Es complicado?

Álvaro: Para nada. Piensa en tu día a día. Constantemente tomas decisiones. Si llueve, coges un paraguas. Si tienes hambre, comes. Los programas hacen lo mismo, solo que necesitan que les demos las reglas.

Alba: ¿Y cuál es la primera regla? ¿Cómo le decimos a la computadora "si pasa esto, haz aquello"?

Álvaro: Usamos una palabra mágica en inglés: IF. Se traduce literalmente como "SI". La lógica es súper simple: SI se cumple una condición, ENTONCES ejecuta un bloque de código.

Alba: A ver, un ejemplo. Si le pido un número al usuario... ¿cómo compruebo si es mayor que 10?

Álvaro: Perfecto. Escribirías algo como: if (numero > 10):. Fíjate en las partes. Tenemos el if, luego la condición numero > 10 entre paréntesis, y súper importante... terminamos con dos puntos.

Alba: Los dos puntos... siempre se me olvidan.

Álvaro: A todos nos pasa al principio. Es la señal para Python que dice: "Oye, prepárate, que aquí viene lo que tienes que hacer si la condición es verdad".

Alba: Okay, entonces después de los dos puntos le digo qué hacer. Por ejemplo, print("Tu número es mayor que 10"). ¿Y cómo sabe que esa línea pertenece al if?

Álvaro: ¡Ah, gran pregunta! Aquí entra algo crucial en Python: la indentación. Todo el código que quieras que se ejecute dentro del if debe tener un pequeño espacio a la izquierda.

Alba: Te refieres a ese espacio que se pone con la tecla Tab, ¿verdad?

Álvaro: ¡Ese mismo! Esa indentación es la forma visual de agrupar el código. Le dice a Python: "Esto de aquí solo se ejecuta si la condición de arriba se cumplió". Si una línea no tiene esa sangría, se ejecutará siempre, después de que el if haya terminado.

Alba: Entendido. El if es para cuando la condición es verdadera. Pero, ¿y si no lo es? ¿Qué pasa si el usuario introduce el número 5? El programa no haría nada.

Álvaro: Exacto. ¿Y qué querríamos que hiciera? Necesitamos un plan B. Para eso, existe otra palabra clave: else. Else significa, literalmente, "si no".

Alba: Ah, claro. Entonces sería: SI la condición se cumple, haz esto, SI NO, haz esto otro.

Álvaro: ¡Lo tienes! La estructura completa sería: if (numero > 10): con su código indentado, y justo debajo, else: con dos puntos, y su propio código indentado. Por ejemplo, print("Tu número NO es mayor que 10").

Alba: Me gusta. Es como darle al programa una respuesta para cada posibilidad. No lo dejas con la duda.

Álvaro: Correcto. Es la base para crear programas que reaccionan de forma inteligente. Y esto nos abre la puerta a estructuras aún más complejas que veremos enseguida, como los bucles.

Alba: Y hablando de poner a prueba lo que aprendemos, tengo aquí un examen de programación real. ¿Qué te parece si lo analizamos?

Álvaro: ¡Perfecto! A ver qué tenemos... Ah, mira, lo primero son las instrucciones generales. Siempre, siempre hay que leerlas con atención.

Alba: Cierto. Dice: "La prueba es INDIVIDUAL, sin apuntes ni calculadora". Y nada de dispositivos electrónicos. Lo básico, pero es fácil olvidarlo con los nervios.

Álvaro: Exacto. Son las reglas del juego. Saberlas te da tranquilidad.

Alba: Ok, la Pregunta 1 parece de física y programación combinadas. Pide calcular una energía térmica, Q, usando una fórmula y un promedio de temperaturas que hay que programar.

Álvaro: Claro. Aquí no solo evalúan si conoces la fórmula Q = m ⋅ c ⋅ ΔT. Quieren ver si puedes escribir un bucle for para leer datos, calcular un promedio y luego aplicar esa fórmula.

Alba: Entiendo. Entonces, es un problema de dos pasos: primero el código para obtener el dato, y luego la matemática.

Álvaro: Precisamente. Mide tu capacidad de integrar conocimientos. Es muy común en exámenes universitarios.

Alba: Ahora, la Pregunta 2 es... ¡un juego de adivinar el número! Esto parece más divertido.

Álvaro: Lo es, pero no te confundas. Esto no evalúa fórmulas, sino lógica pura. ¿Sabes usar condicionales como if y else para dar pistas como "muy alto" o "muy bajo"?

Alba: Ah, claro. Se trata de guiar al usuario. Es un problema de lógica de control, no de cálculo.

Álvaro: Exacto. Son dos tipos de pensamiento muy distintos en un mismo examen. Y eso nos lleva a un punto clave: no todas las preguntas se preparan de la misma manera.

Alba: Vale, entonces ya entendemos qué son los módulos en general. Pero, ¿podemos ver un ejemplo práctico? Uno que sea... útil de verdad.

Álvaro: ¡Claro! Hablemos de uno de mis favoritos: el módulo time. Es súper útil para empezar.

Alba: ¿El módulo "tiempo"? Suena a ciencia ficción. ¿Para qué sirve exactamente?

Álvaro: No es para viajar en el tiempo, lamentablemente. Sirve para que tu programa trabaje con el tiempo. Puedes obtener la hora actual, medir cuánto tarda en ejecutarse una parte de tu código, o incluso hacer que el programa espere.

Alba: Ok, eso de medir la ejecución suena interesante. ¿Cómo lo usamos?

Álvaro: Es muy sencillo. Lo primero, como con cualquier módulo, es importarlo. Simplemente escribes import time al principio de tu script. ¡Y ya está!

Alba: Hecho. ¿Y ahora? ¿Cómo le pido la hora?

Álvaro: Puedes usar time.time(). Esto te da el número de segundos que han pasado desde... el 1 de enero de 1970.

Alba: ¿1970? ¿Por qué esa fecha tan específica?

Álvaro: Es una fecha de referencia en computación, la llaman "la Época" o "Epoch". Pero sí, te devuelve un número gigante y poco útil para nosotros. Piensa en ello como el DNI del tiempo.

Alba: Ya veo... un número larguísimo. ¿No hay una forma más... humana de ver la hora?

Álvaro: Por supuesto. Para eso está time.ctime(). Si usas esa función, te devuelve una cadena de texto con el día, la fecha, la hora y el año. Mucho más amigable.

Alba: ¡Ah, perfecto! Y mencionaste que podíamos hacer que el programa esperara. ¿Cómo funciona eso?

Álvaro: Esa es la función time.sleep(). Le pasas un número de segundos y el programa se detiene por ese tiempo. Por ejemplo, time.sleep(5) lo pausa por cinco segundos.

Alba: Genial, lo usaré para que mi programa de deberes espere mientras yo voy por un café.

Álvaro: ¡Exacto! Es muy útil para controlar el ritmo de un programa. Bueno, ahora que controlamos el tiempo, ¿qué te parece si vemos otro módulo muy popular para generar números al azar?

Alba: Muy bien, Álvaro. Hemos cubierto mucho terreno, pero nos queda un último gran tema.

Álvaro: Así es. Y es uno fundamental. Hablemos de estructuras de datos, específicamente de las listas.

Alba: Suena importante. ¿Qué es exactamente una lista en programación?

Álvaro: ¡Es súper útil! Piensa en una lista como una cajonera o una lista de compras. Es una sola variable que puede guardar un conjunto ordenado de elementos.

Alba: ¿Y qué tipo de elementos puede guardar?

Álvaro: ¡De todo! Números, texto, e incluso otras listas. Son increíblemente flexibles.

Alba: De acuerdo, ¿cómo se ve eso en código? ¿Cómo creamos una?

Álvaro: Es muy fácil. Simplemente usas corchetes. Por ejemplo, edades = . Ahí tienes una lista con tres edades.

Alba: Y si quiero ver solo la primera edad, ¿cómo lo hago?

Álvaro: Buena pregunta. Usas su índice. Pero aquí está el truco... la programación casi siempre empieza a contar desde cero.

Alba: Ah, el famoso índice cero. ¡La clásica primera trampa para principiantes!

Álvaro: ¡Exacto! Para ver el primer elemento, escribirías edades. Para el segundo, edades, y así sucesivamente.

Alba: Y si un valor está mal, ¿puedo cambiarlo?

Álvaro: Claro. Imagina que en esa lista de edades, el segundo valor debería ser 22, no 21. Simplemente escribes edades = 22. Y listo, el valor se actualiza.

Alba: Okay, eso tiene sentido. Pero, ¿qué pasa si necesito agregar una nueva edad a la lista?

Álvaro: Para eso existen los métodos. Usarías .append(). Si haces edades.append(25), el número 25 se añade al final de la lista. Es muy directo.

Alba: ¿Y para eliminar uno?

Álvaro: Puedes usar .pop(). Si le dices edades.pop(0), eliminará el primer elemento. ¡Pop! Y se va.

Alba: Me gusta cómo suena. Fácil de recordar. También vi algo llamado len(). ¿Qué hace?

Álvaro: len() no es un método, sino una función general que te dice el largo de la lista. Es súper útil para saber cuántos elementos tienes antes de, por ejemplo, recorrerla con un ciclo for.

Alba: Perfecto, entonces tenemos cómo crear, leer, actualizar, añadir y borrar elementos. Parece que cubrimos lo básico.

Álvaro: Exacto. Lo clave a recordar es que las listas son colecciones ordenadas y mutables.