TEMA 1: Fundamentos de programación
En este tema veremos los fundamentos básicos de la programación usando el lenguaje PYTHON.
Introducción y Conceptos Clave
¿Qué es programar?
Programar no es más que comunicarnos con un ordenador para pedirle que resuelva un problema o ejecute una tarea específica.
Imagina que tienes que enseñarle a un robot a preparar un bocadillo de jamón y queso, pero el robot es extremadamente literal y no sabe nada por sí mismo. No puedes decirle simplemente "hazme un bocadillo"; tienes que darle cada instrucción paso a paso y en el orden exacto:
- Toma dos rebanadas de pan.
- Coloca una loncha de queso sobre una rebanada.
- Coloca una loncha de jamón sobre el queso.
- Cubre con la otra rebanada de pan.
En informática, ese conjunto de instrucciones ordenadas y finitas se llama Algoritmo. Cuando escribimos ese algoritmo en un lenguaje que el ordenador entiende, estamos programando, y el resultado es un programa o código fuente.
[ Problema Real ] ───► [ Algoritmo (Pasos) ] ───► [ Código Python ] ───► [ Ejecución / Solución ]
El Pensamiento Computacional: Tu nuevo superpoder
El objetivo principal de esta asignatura no es solo aprender sintaxis de código, sino desarrollar el Pensamiento Computacional. Esta es una habilidad de resolución de problemas dividida en cuatro pilares fundamentales:
- Descomposición: Dividir un problema complejo en partes más pequeñas y manejables.
- Reconocimiento de Patrones: Identificar similitudes o tendencias entre problemas anteriores.
- Abstracción: Centrarse únicamente en la información importante e ignorar los detalles irrelevantes.
- Diseño de Algoritmos: Crear una secuencia paso a paso para resolver el problema de forma automática.
🌟 Idea Clave: Aprender a programar te enseña a pensar de forma lógica, estructurada y creativa.
¿Por qué elegimos PYTHON?
Existen cientos de lenguajes de programación (Java, C++, JavaScript, C#...), pero Python es la herramienta idónea para iniciarse y destacar en la actualidad por las siguientes razones:
A. Sintaxis limpia y legible
Python se diseñó priorizando la legibilidad humana. Su código parece casi inglés escrito (o pseudocódigo).
Comparativa: Si quisiéramos mostrar en pantalla el mensaje "¡Hola, mundo!":
En Python:
print("¡Hola, mundo!")
En C++:
#include <iostream>
using namespace std;
int main() {
cout << "¡Hola, mundo!";
return 0;
}
B. Lenguaje multipropósito y líder de la industria
Python no es solo un lenguaje "didáctico", es el lenguaje utilizado por gigantes tecnológicos como Google, NASA, Netflix, Instagram y Spotify. Es el líder absoluto en:
- Inteligencia Artificial y Machine Learning (Chatbots, visión por computador).
- Ciencia de Datos y Análisis Big Data.
- Ciberseguridad y Automatización de Redes.
- Desarrollo Web y Desarrollo de Videojuegos.
C. Gran Comunidad y Ecosistema
Al ser un lenguaje de código abierto de enorme popularidad, cuenta con miles de librerías gratuitas que permiten realizar tareas complejas con muy pocas líneas de código.
Infografía resumida: ¿Por qué Python?
Recursos Audiovisuales Recomendados
Para complementar la lectura y consolidar conceptos, visualiza los siguientes vídeos breves recomendados:
¿Qué es la programación y cómo pensar de forma lógica?
- Título: Conceptos de programación en 6 minutos
- Autor: Pol Vallverdu
- Descripción: Un repaso rápido y muy didáctico a los fundamentos esenciales que todo estudiante debe conocer antes de teclear su primera línea de código.
Preparación del Entorno de Trabajo: Instalación, Configuración y "¡Hola, Mundo!"
¿Qué herramientas necesitamos para programar?
Para empezar a programar en Python necesitamos dos herramientas fundamentales que trabajan juntas:
- El Intérprete de Python: Es el "cerebro" o traductor. Lee las instrucciones que escribimos en lenguaje Python y las traduce a lenguaje máquina (0s y 1s) para que el procesador del ordenador las ejecute.
- Visual Studio Code (VS Code): Es nuestro "cuaderno de trabajo inteligente" o IDE / Editor de código. Nos proporciona resaltado de colores, corrección de errores en tiempo real, autocompletado y una terminal integrada para ejecutar nuestros programas de forma cómoda.
Guía de instalación según tu Sistema Operativo
Vamos a ver como istalarlo en EducAndOS v2, Windows 10/11, macOS.
Intérprete de Python: Viene preinstalado de fábrica en el sistema. Puedes comprobarlo abriendo la Terminal (
Ctrl + Alt + T) y escribiendo:python3 --versionInstalación de Visual Studio Code:
Opción A (Centro de Software): Abre el Centro de Software / Software de EducAndOS, busca "Visual Studio Code" o "VS Code" y haz clic en Instalar. Centro de software (o Herramientas del sistema > Centro de software), busca 'Visual Studio Code' o 'VS Code' y pulsa en Instalar." type="suggestion">
Opción B (Descarga Oficial .deb):
Entra en la web oficial: code.visualstudio.com.
Descarga el paquete
.deb(Debian/Ubuntu).Haz doble clic sobre el archivo descargado para abrir el instalador de paquetes y pulsa en Instalar.
Instalación de Python:
Entra en python.org/downloads.
Haz clic en el botón amarillo Download Python 3.x.x.
Ejecuta el archivo
.exedescargado.⚠️ PASO CRÍTICO: En la primera pantalla del instalador, marca obligatoriamente la casilla:
☑ Add python.exe to PATH(Añadir Python al PATH)Haz clic en Install Now y espera a que finalice.
Instalación de Visual Studio Code:
Entra en code.visualstudio.com.
Descarga el instalador para Windows.
Ejecuta el archivo y sigue el asistente dejando las opciones por defecto habilitadas (recomendado marcar "Agregar 'Abrir con Code' al menú contextual").
Instalación de Python:
Entra en python.org/downloads.
Descarga el instalador del paquete
.pkgpara macOS.Haz doble clic y sigue los pasos del asistente de instalación.
Instalación de Visual Studio Code:
Entra en code.visualstudio.com.
Descarga la versión para Mac (archivo
.zip).Descomprime el archivo y arrastra el icono de Visual Studio Code a la carpeta
Aplicaciones.
Configuración de extensiones (Plugins) en VS Code
Una vez instalado Visual Studio Code, abrimos la aplicación y nos dirigimos al menú de Extensiones en la barra lateral izquierda (o pulsando el atajo Ctrl + Shift + X en Windows/Linux o Cmd + Shift + X en Mac).
Instalaremos las siguientes extensiones recomendadas:
| Extensión | Creador / Búsqueda | Función Principal |
|---|---|---|
| Spanish Language Pack | Microsoft | Traduce toda la interfaz de VS Code al español. |
| Python | Microsoft | Añade soporte completo para lenguaje Python, autocompletado y ejecución directa. |
| Pylance | Microsoft | Proporciona análisis dinámico de errores e información contextual de funciones. |
Material Icon Theme (Opcional) | PKief | Asigna iconos visuales a los archivos según su extensión (.py, .html, etc.). |
💡 Nota: Tras instalar el Spanish Language Pack, VS Code te pedirá reiniciar el programa para aplicar el idioma español.
Tu primer programa: "¡Hola, Mundo!"
Es una tradición en la informática que el primer programa que escribe cualquier estudiante sirva para mostrar el mensaje "¡Hola, Mundo!" en pantalla.
Paso a paso para crear y ejecutar tu programa:
Crea una carpeta de trabajo:
En tu equipo o pendrive, crea una carpeta llamada
Python.
Abre la carpeta en VS Code:
En VS Code, ve a Archivo > Abrir carpeta... (o Open Folder) y selecciona la carpeta que acabas de crear.
Crea tu primer archivo Python:
Haz clic en el icono de Nuevo Archivo (
+) en el explorador lateral de VS Code.Nombra el archivo exactamente como:
hola.py(la extensión.pyes fundamental para que el sistema sepa que es código Python).
Escribe el código:
En el editor de texto a la derecha, escribe la siguiente línea:
# Mi primer programa en Python
print("¡Hola, Mundo!")
Ejecuta el programa:
Método 1 (Recomendado): Haz clic en el botón de reproducción ▶️ (Run Python File) ubicado en la esquina superior derecha de la ventana.
Método 2 (Terminal integrada): Ve al menú Terminal > Nueva Terminal y escribe:
En Windows:
python hola.pyEn EducAndOS v2 / Mac:
python3 hola.py
Errores frecuentes y solución de problemas
"python no se reconoce como un comando interno o externo..." (Windows):
Causa: Olvidaste marcar la casilla
Add python.exe to PATHdurante la instalación.Solución: Vuelve a ejecutar el instalador de Python, selecciona la opción Modify / Repair y asegúrate de activar la casilla PATH.
No aparece el botón de reproducción ▶️:
Causa: La extensión de Python (Microsoft) no está instalada o activada.
Solución: Revisa la pestaña de extensiones (
Ctrl+Shift+X) e instala la extensión oficial de Microsoft.El intérprete no está seleccionado ("Select Interpreter"):
Solución: Pulsa
Ctrl + Shift + P(oCmd + Shift + Pen Mac), escribePython: Select Interpretery selecciona la versión de Python instalada en tu sistema.El código no se ejecuta con los cambios más recientes:
Causa: Olvidaste guardar el archivo antes de ejecutar.
Solución: Habilita el guardado automático en Archivo > Guardado automático (Auto Save) o pulsa
Ctrl + S.📝 Retos Prácticos en Clase
Reto 1 (Personalización): Modifica el archivo
hola.pypara que además del saludo inicial muestre en líneas separadas tu nombre, tu curso y cuál es tu videojuego o aplicación favorita utilizando varias instruccionesprint().Reto 2 (Arte ASCII): Intenta utilizar varias sentencias
print()consecutivas para proyectar un dibujo sencillo en la terminal (por ejemplo, una carita sonriente o una pirámide con asteriscos*).
Elementos Básicos de Programación en Python
Ahora que ya tenemos nuestro entorno de trabajo configurado, ¡es hora de empezar a hablar en Python! En este apartado conoceremos las piezas fundamentales con las que construiremos cualquier programa.
Algoritmos en la Programación
Un algoritmo es una secuencia ordenada, finita y no ambigua de instrucciones lógicas diseñadas para resolver un problema o realizar una tarea específica.
Propiedades fundamentales de un algoritmo
- 🏁 Finito: Posee un punto de inicio y un número determinado de pasos con un final definido.
- 🎯 Preciso: Cada instrucción es rigurosa, clara y unívoca, sin margen de ambigüedad.
- 🔄 Definido: Dados idénticos datos de entrada, el algoritmo devuelve exactamente el mismo resultado en cada ejecución.
- ⚡ Eficiente: Optimiza el uso de recursos computacionales (tiempo de CPU y consumo de memoria RAM).
📥 Entrada (Input) ──> ⚙️ Procesamiento (Algoritmo) ──> 📤 Salida (Output)
💡 Enfoque Pythonic: En Python, los algoritmos se diseñan priorizando la legibilidad, la elegancia estructural y el aprovechamiento de las funciones nativas optimizadas en C.
Sintaxis y Comentarios
La sintaxis de Python fue diseñada priorizando la comprensión humana, fundamentada en los principios del PEP 20 ("The Zen of Python").
Indentación obligatoria
A diferencia de lenguajes derivados de C o Java, Python no utiliza llaves ({}) ni palabras reservadas de apertura/cierre. La jerarquía y los bloques de control se definen exclusivamente por sangría o indentación (el estándar PEP 8 prescribe 4 espacios en blanco por nivel).
# Ejemplo de indentación estructurada
temperatura = 28
if temperatura > 25:
print("🔥 Hace calor")
print("❄️ Enciende la ventilación")
else:
print("🍃 Temperatura agradable")
Comentarios y Documentación
Son fragmentos de texto ignorados por el intérprete cuyo fin es documentar la lógica detrás del código.
# 1. Comentario de una sola línea: describe el propósito inmediato
radio_circulo = 5.0 # Medida expresada en centímetros (inline comment)
def calcular_area_rectangulo(base: float, altura: float) -> float:
# 2. Comentarios multilínea:
"""Calcula el área superficial de un rectángulo.
Parámetros:
base (float): Longitud horizontal de la figura.
altura (float): Longitud vertical de la figura.
Retorna:
float: El producto escalar de la base por la altura.
"""
return base * altura
#Peidmos la base y la altura por teclado y
#calculamos el are llamado a la funcion calcular_area_rectangulo(base,altura)
b= float(input("Intoduce la base: "))
h= float(input("Intoduce la altura: "))
print(f"Rectangulo con base {b} y altura {h}, su area es {calcular_area_rectangulo(b,h)}")
Variables y Constantes
Variables y Tipado Dinámico Fuerte
En Python, una variable no es una celda fija de memoria, sino un identificador o etiqueta de referencia que apunta a un objeto en memoria dinámica.
- 🔀 Tipado dinámico: No se declaran tipos de antemano; el intérprete infiere el tipo de dato del objeto referenciado en tiempo de ejecución.
- 🛡️ Tipado fuerte: No ocurren conversiones automáticas implícitas entre tipos no compatibles (por ejemplo, sumar texto y enteros genera un error
TypeError).
#Asignación y reasignación dinámica de tipos
usuario = "Carlos" # usuario referencia un objeto str
print(type(usuario)) # <class 'str'>
usuario = 42 # Ahora la misma etiqueta apunta a un objeto int
print(type(usuario)) # <class 'int'>
#Asignación múltiple y desempaquetado simultáneo
x, y, z = 10, 20, 30
a = b = c = 0
Reglas de Nomenclatura (PEP 8)
Usar
snake_casepara nombres de variables y funciones:saldo_actual,fecha_nacimiento.Deben comenzar con una letra (
a-z,A-Z) o un guion bajo (_).No pueden comenzar con números ni contener espacios o símbolos especiales (
@,-,$).Distinguen entre mayúsculas y minúsculas:
edad,EdadyEDADson tres identificadores independientes.
Constantes
Python no tiene una palabra clave inmutable como const. Se gestionan por convención y mediante anotaciones de tipado estático:
#Convención estándar PEP 8 (SCREAMING_SNAKE_CASE)
PI = 3.141592653589793
VELOCIDAD_DE_LA_LUZ = 299792458 # en m/s
print(f"PI ={PI} y la velocidad de la luz es: {VELOCIDAD_DE_LA_LUZ} m/s")
Declaración, documentación e intercambio de variables
Define dos variables con nombres legibles que contengan las dimensiones de un terreno rectangular en metros (ancho y largo), documenta la lógica con un comentario multilínea y calcula su perímetro y área. Luego, intercambia los valores de ambas variables usando la asignación múltiple de Python sin recurrir a una variable temporal auxiliar.
Entrada y Salida (I/O)
Salida con print()
La función nativa print() envía representaciones textuales al flujo estándar de salida (stdout, por defecto la consola de comandos). Su firma formal completa es:
print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
#Parámetros avanzados: separador (sep) y finalizador (end)
print("Python", "es", "potente", sep=" 🚀 ")
print("Procesando", end="...")
print(" ¡Listo! ✅")
#Formateo con cadenas literales interpoladas (f-strings)
articulo = "Monitor 4K"
precio = 349.99
cantidad = 2
print(f"📦 Pedido: {articulo} | Total: ${precio * cantidad:,.2f}")
#Relleno con ceros a la izquierda y alineación
codigo = 85
print(f"ID Factura: {codigo:06d}") # Salida: ID Factura: 000085
A. Concatenación de Texto con Variables
Existen cuatro métodos principales para unificar texto y variables en una salida, cada uno con sus ventajas y casos de uso:
Paso de múltiples argumentos por coma (
,):Inserta automáticamente un espacio en blanco entre cada argumento (definido por
sep).Realiza casting implícito a texto: no arroja error si se pasan enteros, flotantes o listas.
nombre = "Laura"
edad = 26
print("Usuario:", nombre, "| Edad:", edad)
# Salida: Usuario: Laura | Edad: 26
+):Une exclusivamente cadenas de texto (
str).Requiere casting explícito previo: intentar concatenar tipos numéricos genera un error
TypeError.
nombre = "Laura"
edad = 26
#print("Edad: " + edad) -> Genera TypeError: can only concatenate str to str
#Requiere conversión explícita:
print("Usuario: " + nombre + " | Edad: " + str(edad))
3. Método .format() (Python 2.7 / 3.0+):
Utiliza llaves
{}posicionales o nominales como marcadores de posición (placeholders).
nombre = "Laura"
edad = 26
# Marcadores posicionales e indexados
print("Hola, {}! Tienes {} años.".format(nombre, edad))
print("Total: {2} € (Cantidad: {1}, Precio base: {0} €)".format(50, 100, 500))
f-strings, estándar moderno desde Python 3.6+):Es el mecanismo más rápido, limpio y recomendado por la comunidad (PEP 498).
Permite evaluar expresiones arbitrarias de Python directamente dentro de las llaves
{}.
nombre = "Laura"
edad = 26
saldo = 1250.75
print(f"Cliente: {nombre.upper()} | Saldo con bono: {saldo + 200} €")
# Salida: Cliente: LAURA | Saldo con bono: 1450.75 €
B. Control de Separadores y Saltos de Línea (sep y end)
Por defecto, cada llamada a print() finaliza con un salto de línea (\n) y separa los elementos con un espacio simple ( ). Estos comportamientos pueden modificarse mediante los parámetros por palabra clave:
sep(separador entre argumentos): Modifica el carácter o cadena insertada entre cada valor.end(terminador de flujo): Determina qué carácter se emite al final de la instrucción en lugar de saltar de línea.
# 1. Modificación de separadores con 'sep'
dia, mes, anio = 12, 10, 2026
print(dia, mes, anio, sep="/") # Salida: 12/10/2026
print("servidor", "puerto", "ssl", sep=" -> ") # Salida: servidor -> puerto -> ssl
print("A", "B", "C", sep="") # Salida: ABC (sin separación)
# 2. Control de saltos de línea con 'end'
# Evitar el salto de línea para imprimir en la misma fila:
print("Descargando archivo", end="...")
print(" [50%]", end="...")
print(" ¡Completado! ✅")
# Salida en una sola línea: Descargando archivo... [50%]... ¡Completado! ✅
# 3. Combinación de sep y end para generar tablas compactas:
print("ID", "PRODUCTO", "STOCK", sep="\t", end="\n--------------------------\n")
print("001", "Teclado", 45, sep="\t")
print("002", "Ratón", 120, sep="\t")
C. Formateo Avanzado de Números con f-strings
El mini-lenguaje de especificación de formato de Python se activa tras colocar dos puntos : dentro de las llaves {variable:especificador}:
1. Control de decimales y redondeo (.Nf)
pi = 3.14159265359
print(f"Pi (2 decimales): {pi:.2f}") # Salida: 3.14 (redondeo estándar)
print(f"Pi (4 decimales): {pi:.4f}") # Salida: 3.1416
2. Separadores de miles y notación monetaria
presupuesto = 15893400.854
# Usa coma como separador de miles y 2 posiciones decimales:
print(f"Presupuesto: ${presupuesto:,.2f}") # Salida: $15,893,400.85
# Usa guion bajo como separador de miles (estándar PEP 515):
print(f"Presupuesto: {presupuesto:_.2f}") # Salida: 15_893_400.85
3. Notación porcentual (%)
tasa_aprobados = 0.8475
print(f"Éxito: {tasa_aprobados:.1%}") # Salida: 84.8%
print(f"Preciso: {tasa_aprobados:.2%}") # Salida: 84.75%
4. Notación científica (e o E)
masa_electron = 9.1093837e-31
print(f"Masa: {masa_electron:.3e} kg") # Salida: 9.109e-31 kg
5. Relleno con ceros, alineación y anchura de columnas
| Especificador | Significado | Entrada | Código | Salida |
|---|---|---|---|---|
:0Nd | Rellena con ceros hasta $N$ dígitos enteros |
|
|
|
| Alinea a la izquierda con un ancho de $N$ |
|
|
|
| Alinea a la derecha con un ancho de $N$ |
|
|
|
| Alinea al centro con un ancho de $N$ |
|
|
|
# Ejemplo de alineación en columna tabular
print(f"{'PRODUCTO':<15} | {'PRECIO':>10} | {'CÓDIGO':^8}")
print("-" * 39)
print(f"{'Monitor 4K':<15} | {349.90:>10.2f} | {850:^8d}")
print(f"{'Cable HDMI':<15} | {12.50:>10.2f} | {35:^8d}")
6. Conversión a bases numéricas (Binario, Octal, Hexadecimal)
numero = 255
print(f"Binario: {numero:b}") # 11111111
print(f"Octal: {numero:o}") # 377
print(f"Hex minusc: {numero:x}") # ff
print(f"Hex mayusc: {numero:X}") # FF
print(f"Hex prefijo: {numero:#x}") # 0xff
Entrada con input()
Pausa la ejecución para recibir datos desde el teclado. Siempre captura el contenido como cadena de texto (str).
#para ejecutar este codigo online debes activar la opción stdin y escribir los datos en distintas líneas pulsando intro
nombre = input("👤 Introduce tu nombre: ")
edad_str = input("🎂 Introduce tu edad: ")
print(f"Hola {nombre}, tu edad es {edad_str}, el tipo nativo capturado es {type(edad_str)}")
Casting (Conversión de Tipos)
Conversión Implícita (Coerción)
El intérprete promociona tipos menores a mayores para evitar truncamiento o pérdida de precisión.
num_entero = 10 # int
num_decimal = 4.75 # float
suma = num_entero + num_decimal # El entero se promociona automáticamente a float
print(suma, type(suma)) # 14.75 <class 'float'>
Conversión Explícita
El desarrollador invoca constructores nativos para forzar la transformación.
| Constructor | Función y Propósito | Ejemplo Práctico | Resultado Obtenido |
|---|---|---|---|
| 🔢 Convierte a entero (trunca decimales o parsea dígitos) |
|
|
| 🌐 Convierte a número de coma flotante |
|
|
| 🔤 Genera representación en texto |
|
|
| ⚖️ Evalúa el valor de verdad booleano |
|
|
#Ejemplo práctico: Lectura y cálculo seguro
precio_unitario = float(input("💶 Precio: "))
unidades = int(input("📦 Cantidad: "))
total = precio_unitario * unidades
print(f"Importe final: {total:.2f} €")
Factura comercial con input(), casting y formato tabular
Construye un generador de recibos simplificado. El programa debe solicitar (o recibir) el nombre de un artículo tecnológico, la cantidad de unidades compradas (en texto) y el precio unitario en euros (en texto). Realiza el casting necesario, calcula el subtotal, un IVA del 21% y el total definitivo. Imprime un recibo estructurado en columnas alineadas con separadores de miles y 2 posiciones decimales.
Factura comerial con input(), casting y formato tabular.
Abre el simulador y haz cambios y pruébalos
Operadores en Python
Operadores Aritméticos
Ejecutan operaciones matemáticas sobre operandos numéricos:
a, b = 15, 4
print(a + b) # ➕ Suma: 19
print(a - b) # ➖ Resta: 11
print(a * b) # ✖️ Multiplicación: 60
print(a / b) # ➗ División real (siempre produce float): 3.75
print(a // b) # 🔢 División entera (cociente trunco): 3
print(a % b) # 🔄 Módulo (resto de la división): 3
print(a ** b) # ⚡ Potenciación (15^4): 50625
Operadores de Comparación (Relacionales)
Verifican condiciones de orden o equivalencia, retornando un valor booleano (True / False):
x, y = 12, 25
print(x == y) # Igualdad: False
print(x != y) # Desigualdad: True
print(x > y) # Mayor estricto: False
print(x < y) # Menor estricto: True
print(x >= 12) # Mayor o igual: True
print(x <= 10) # Menor o igual: False
# 🔗 Comparaciones encadenadas idiomáticas
edad = 28
print(18 <= edad < 65) # Equivale a: (18 <= edad) and (edad < 65) -> True
Operadores Lógicos
¿Qué son los Operadores Lógicos?
- "Saldré a correr si no llueve y he terminado los deberes."
- "Me compro el videojuego si está de oferta o si me dan la paga."
True (Verdadero) o False (Falso).and, or y not.El Operador and (Conjunción - "Y")
and es el más exigente: devuelve True SOLO si todas las condiciones que conecta son verdaderas simultáneamente. Si falla aunque sea una sola, el resultado final será False.| Condición A | Condición B | Resultado (A and B) |
|---|---|---|
| False | False | ❌ False |
| False | True | ❌ False |
| True | False | ❌ False |
| True | True | ✅ True |
# Para aprobar la asignatura necesitas al menos un 5 en el examen Y haber entregado el proyecto
nota_examen = 6.5
proyecto_entregado = True
aprueba = (nota_examen >= 5.0) and (proyecto_entregado == True)
print("¿Aprueba la evaluación?:", aprueba) # Muestra: True
El Operador or (Disyunción - "O")
El operador or es flexible: devuelve True si AL MENOS UNA de las condiciones es verdadera (o si lo son todas). Solo devuelve False cuando absolutamente todas las condiciones son falsas.
💡 Analogía de clase
Imagina que llegas a la caja de un supermercado. Te dejan llevarte la compra si pagas con efectivo O con tarjeta. Te vale cualquiera de las dos opciones (e incluso llevar ambas en la cartera). Solo te quedas sin compra si no llevas ni efectivo ni tarjeta.
📊 Tabla de Verdad del operador or
| Condición A | Condición B | Resultado (A OR B) |
|---|---|---|
| False | False | ❌ False |
| False | True | ✅ True |
| True | False | ✅ True |
| True | True | ✅ True |
# Entras gratis al museo si eres menor de 14 años O si es domingo
edad = 16
dia_semana = "domingo"
entrada_gratis = (edad < 14) or (dia_semana == "domingo")
print("¿Entra gratis al museo?:", entrada_gratis) # Muestra: True (aunque tiene 16 años, hoy es domingo)
El Operador not (Negación - "NO")
not es un operador unario, lo que significa que actúa sobre una sola condición. Su única misión es invertir el valor de verdad: lo que es True lo convierte en False, y lo que es False lo convierte en True.| Condición A | Resultado (not A) |
|---|---|
| True | ❌ False |
| False | ✅ True |
modo_avion = False
# Se lee exactamente como en español: "Si NO está en modo avión..."
if not modo_avion:
print("📶 Buscando redes Wi-Fi y datos móviles disponibles...")
else:
print("✈️ Conexiones inalámbricas desactivadas.")
"""
📌 Consejo de buen programador: En lugar de escribir if modo_avion == False:,
en Python es mucho más limpio y profesional escribir if not modo_avion:.
"""
Operadores de Membresía (in, not in)
Determinan si un elemento pertenece a una secuencia o colección iterable:
titulo = "Introducción a Python 3"
servidores = ["web-01", "db-01", "cache-01"]
rol_usuario = {"admin": True, "editor": False}
print("Python3" in titulo) # False (búsqueda en texto)
print("proxy-01" not in servidores) # True (no está en la lista)
print("editor" in rol_usuario) #True (evalúa las CLAVES)
print(True in rol_usuario) #False (no busca en valores directamente)
Los 3 Errores Típicos
❌ Error 1: Omitir la variable tras el operador lógico
En español decimos "Si la nota es igual a 9 o 10", pero en Python no puedes escribir eso directamente:
nota = 7
# ❌ MAL (¡Trampa! Esto dará True siempre porque el número 10 suelto cuenta como True)
if nota == 9 or 10:
print("Sobresaliente")
# ✅ BIEN (Hay que repetir la comparación completa a ambos lados del 'or')
if nota == 9 or nota == 10:
print("Sobresaliente")
❌ Error 2: Confundir and y or al comprobar rangos numéricos
Si queremos saber si una temperatura está fuera de los límites normales (por ejemplo, menor de 0 °C o mayor de 40 °C):
temperatura = -5
# ❌ MAL: ¡Ningún número del universo puede ser menor que 0 Y mayor que 40 al mismo tiempo!
if temperatura < 0 and temperatura > 40:
print("Alerta climática")
# ✅ BIEN: Usamos 'or' para valores extremos separados, y 'and' para valores dentro de un intervalo
if temperatura < 0 or temperatura > 40:
print("Alerta climática")
❌ Error 3: Escribir los operadores en mayúsculas
Recuerda que en Python los booleanos empiezan por mayúscula (True, False), pero los operadores lógicos van siempre en minúscula (and, or, not). Escribir AND u OR provocará un SyntaxError.
Autoevaluación operadores lógicos
Resuelve mentalmente todos los resultados y luego dale a RUN para comprobar tus aciertos
Operador Ternario (Expresión Condicional)
Evalúa una condición en una sola línea compacta:
Valor_si_verdadero if condición else valor_si_falso
calificacion = 82
estado = "Aprobado ✅" if calificacion >= 60 else "Suspendido ❌"
print(estado)
# 💡 Inserción directa dentro de una f-string
temperatura = 32
print(f"Ambiente: {'Caluroso 🌡️' if temperatura > 30 else 'Templado ⛅'}")
Tipos de Datos Primitivos y Escalares
Números
Enteros (int)
Almacenan números sin parte decimal con precisión arbitraria ilimitada (limitada únicamente por la memoria disponible).
poblacion = 8_000_000_000 # Los guiones bajos mejoran la legibilidad
deuda = -450
print(f"Nª de habitantes {poblacion:,.0f} y es de tipo {type(poblacion)}")
print(f"la variable deuda tiene el valor {deuda} y es de tipo {type(deuda)}")
Flotantes (float)
Números decimales representados conforme al estándar binario de 64 bits IEEE 754.
gravedad = 9.80665
constante_planck = 6.626e-34 # 6.626 x 10^-34
Números Complejos (complex)
Poseen parte real y parte imaginaria denotada mediante la letra j ($j = \sqrt{-1}$):
z1 = 4 + 3j
z2 = complex(2, -5) # 2 - 5j
print(f"Complejo: {z1}")
print(f"Parte real: {z1.real}") # 4.0
print(f"Parte imaginaria: {z1.imag}") # 3.0
print(f"Conjugado: {z1.conjugate()}") # (4-3j)
print(f"Suma compleja: {z1 + z2}") # (6-2j)
Cadenas de Texto (str)
Secuencias ordenadas e inmutables de caracteres codificados bajo estándar UTF-8.
lenguaje = "Python"
# Indexación (índices positivos y negativos)
print(lenguaje[0]) # 'P' (primer carácter)
print(lenguaje[-1]) # 'n' (último carácter)
# Slicing / Rebanado [inicio : fin : paso]
print(lenguaje[0:4]) # 'Pyth'
print(lenguaje[::-1]) # 'nohtyP' (invierte el texto)
# Métodos esenciales de transformación
frase = " análisis de datos "
print(frase.strip()) # Elimina espacios periféricos
print(frase.strip().title()) # "Análisis De Datos"
print("csv;json;xml".split(";")) # ['csv', 'json', 'xml']
print(" / ".join(["A", "B", "C"])) # "A / B / C"
Booleanos (bool)
True (1) y False (0).Colecciones y Estructuras de Datos
Listas (list)
tecnologias = ["Python", "SQL", "Docker"]
# Modificación directa por índice
tecnologias[1] = "PostgreSQL"
# Métodos de manipulación
tecnologias.append("Git") # Inserta al final
tecnologias.insert(1, "Linux") # Inserta en el índice indicado
tecnologias.extend(["AWS", "FastAPI"]) # Concatena múltiples elementos
tecnologias.remove("Docker") # Elimina la primera ocurrencia por valor
extraido = tecnologias.pop() # Extrae y retorna el último elemento
tecnologias.sort() # Ordena alfabéticamente in situ
print("Lista resultante:", tecnologias)
Tuplas (tuple)
# Creación y acceso
servidor_dns = ("8.8.8.8", 53)
tupla_unitaria = ("valor_unico",) # Requiere coma final
ip, puerto = servidor_dns # Desempaquetado automático (unpacking)
print(f"IP: {ip}, Puerto: {puerto}")
# 🔄 Intercambio de variables sin variable temporal
a, b = 100, 200
a, b = b, a
print(f"a: {a}, b: {b}") # 200, 100
Conjuntos (set)
# Eliminación automática de duplicados
etiquetas = {"dev", "ops", "cloud", "dev", "ops"}
print(etiquetas) # {'dev', 'ops', 'cloud'}
vacio = set() # set() define conjunto vacío; {} crea un diccionario
# Álgebra de conjuntos
grupo_1 = {1, 2, 3, 4}
grupo_2 = {3, 4, 5, 6}
print(grupo_1 | grupo_2) # ∪ Unión: {1, 2, 3, 4, 5, 6}
print(grupo_1 & grupo_2) # ∩ Intersección: {3, 4}
print(grupo_1 - grupo_2) # ➖ Diferencia: {1, 2}
print(grupo_1 ^ grupo_2) # ⊕ Diferencia simétrica: {1, 2, 5, 6}
Diccionarios (dict)
- 🔑 Claves: Deben ser objetos inmutables y únicos (
str,int,tuple). - 📦 Valores: Pueden ser de cualquier tipo y admiten duplicados.
servidor = {
"ip": "192.168.1.10",
"nombre": "SRV-DATOS",
"puertos_abiertos": [22, 80, 443],
"activo": True
}
# Acceso seguro con valor por defecto
memoria = servidor.get("ram_gb", 16) # Retorna 16 si la clave no existe
# Modificación y adición
servidor["ip"] = "192.168.1.50"
servidor["zona"] = "eu-west-1"
# Inspección de componentes
print("Claves:", list(servidor.keys()))
print("Valores:", list(servidor.values()))
print("Pares:", list(servidor.items()))
Matriz Comparativa de Colecciones
| Colección | Sintaxis | ¿Ordenada? | ¿Mutable? | ¿Admite Duplicados? | Acceso a Elementos | Caso de Uso Habitual |
|---|---|---|---|---|---|---|
| 📜 Lista |
| Sí | Sí | Sí | Por índice entero (l[0]) | Secuencias dinámicas modificables |
| 🔒 Tupla |
| Sí | No | Sí | Por índice entero (t[0]) | Registros fijos, claves compuestas |
| 🎯 Conjunto |
| No | Sí | No | Por pertenencia (x in s) | Unicidad y operaciones de conjuntos |
| 🗂️ Diccionario |
| Sí (inserción) | Sí | Claves no, valores sí | Por clave única (d["k"]) | Mapeo de atributos y consultas directas |
Control de Flujo Condicional: if, elif, else
Las estructuras condicionales permiten que el flujo de ejecución del programa tome diferentes caminos (bifurcaciones) en función de si una o más expresiones booleanas se evalúan como verdaderas (True) o falsas (False).
Estructura Básica: if y else
La cláusula if ejecuta su bloque de código asociado si y solo si la condición es verdadera. Si es falsa, y existe un bloque else, este último se ejecutará como alternativa predeterminada.
Reglas de sintaxis:
- La expresión condicional finaliza obligatoriamente con dos puntos (
:). - El bloque que compone la acción debe estar indentado obligatoriamente (4 espacios).
- La cláusula else es opcional; no evalúa ninguna condición propia y solo se dispara cuando el
ifprecedente evalúa aFalse.
edad_cliente = 17
if edad_cliente >= 18:
print("✅ Acceso concedido: Cliente mayor de edad.")
else:
print("⛔ Acceso denegado: El cliente es menor de edad.")
Múltiples Decisiones: Estructura if - elif - else
Cuando un problema presenta más de dos estados posibles excluyentes, se utiliza la palabra reservada elif (contracción de else if).
Dinámica de evaluación:
- Python evalúa las condiciones de arriba hacia abajo secuencialmente.
- En el instante en que una condición resulta verdadera (
True), el intérprete ejecuta su bloque asociado y salta automáticamente fuera de toda la estructura condicional, ignorando loselify elelserestantes. - El bloque final
elseactúa como un comportamiento por defecto (fallback) cuando ninguna de las condiciones anteriores se cumplió.
calificacion = 87
if calificacion >= 90:
nivel = "Sobresaliente 🌟"
elif calificacion >= 80:
nivel = "Notable 👍"
elif calificacion >= 70:
nivel = "Bien 📘"
elif calificacion >= 60:
nivel = "Suficiente ⚠️"
else:
nivel = "Insuficiente ❌"
print(f"Puntuación: {calificacion} -> Nivel asignado: {nivel}")
# Salida: Puntuación: 87 -> Nivel asignado: Notable 👍
⚠️ Atención al orden de las condiciones: Si colocas una condición más amplia antes que una más restrictiva (por ejemplo, comprobar calificacion >= 60 antes que calificacion >= 90), el primer bloque capturará los valores y nunca se alcanzarán los bloques posteriores.
Condiciones Anidadas (Nested if-else)
Un if-else anidado consiste en situar una estructura condicional completa dentro del bloque indentado de otra estructura condicional. Se utiliza cuando una segunda comprobación sólo tiene sentido lógico si la primera se ha verificado previamente.
usuario_autenticado = True
rol_usuario = "editor"
recurso_bloqueado = False
if usuario_autenticado:
print("🔑 Sesión activa.")
# Condicional anidado de segundo nivel
if rol_usuario == "admin":
print("👑 Permisos totales de administrador concedidos.")
elif rol_usuario == "editor":
# Condicional anidado de tercer nivel
if not recurso_bloqueado:
print("✏️ Permiso concedido: El editor puede modificar el artículo.")
else:
print("🔒 Recurso temporalmente bloqueado para edición.")
else:
print("👀 Permiso de solo lectura.")
else:
print("❌ Error 401: Usuario no autenticado. Por favor, inicia sesión.")
💡 Buenas Prácticas sobre Anidamiento (Refactorización):
Un anidamiento excesivo (más de 2-3 niveles) genera el llamado "Código Flecha" (Arrow Anti-Pattern), haciendo que el código sea difícil de leer y mantener. Se recomienda simplificarlo mediante:
- Operadores lógicos (
and,or): para unir condiciones interdependientes. - Patrón de retorno temprano / Guard Clauses: salir de la lógica antes si la condición no es válida.
Evaluación en Cortocircuito
- En un bloque con
and: si la primera subcondición esFalse, no se evalúan las siguientes, porque el resultado final inevitablemente seráFalse. - En un bloque con
or: si la primera subcondición esTrue, no se evalúan las siguientes, porque el resultado final inevitablemente ya seráTrue.
usuario = {"nombre": "Beatriz", "activo": True, "intentos": 0}
# Comprueba la clave antes de acceder a ella, previniendo un error KeyError:
if "intentos" in usuario and usuario["intentos"] == 0:
print("🟢 Cuenta en estado óptimo.")
Sistema de autorización por niveles con anidamiento
Enunciado: Desarrolla un evaluador de peticiones HTTP para un servidor en producción. Debe comprobar:
Si la sesión está autenticada. Si no lo está, denegar con código 401.
Si el perfil es "root", acceso total concedido.
Si el perfil es "devops", permitir acceso si el servidor está en mantenimiento con advertencia técnica, o acceso estándar si no lo está.
Si el perfil es "invitado", rechazar el acceso si está en mantenimiento o dar acceso de solo lectura en caso normal.
Cualquier otro perfil se considerará inválido.
Simulador Sistema de autorización por niveles con anidamiento
Abre el simulador y haz los cambios que quieras.
Estructura de Selección Múltiple match-case en Python
Introducción: ¿Qué es la estructura match-case?
Hasta ahora hemos utilizado cadenas de if - elif - else cuando necesitábamos que un programa tomara decisiones entre varias opciones. Sin embargo, cuando tenemos que evaluar una única variable frente a una lista conocida de valores, esas cadenas pueden volverse repetitivas y difíciles de leer.
A partir de Python 3.10, se incorporó al lenguaje la sentencia match-case, una herramienta conocida en ciencias de la computación como coincidencia de patrones estructurales (Structural Pattern Matching). Equivale al clásico bloque switch-case de otros lenguajes como C, Java o JavaScript, pero con una sintaxis mucho más limpia, moderna y potente.
Sintaxis Básica y Reglas de Escritura
La estructura requiere dos palabras clave fundamentales:
match: indica la variable o expresión que queremos inspeccionar.case: define cada una de las opciones posibles que queremos comprobar._(guion bajo): actúa como el caso por defecto (comodín o wildcard). Si ningúncaseprevio ha coincidido, se ejecuta este bloque (cumple la misma función que elelsefinal).
# ====================================================================
# ESTRUCTURA CANÓNICA DE MATCH-CASE
# ====================================================================
opcion= 2 #opcion = int(input("Elige una opción (1-3): ")) /para que la opcion la
#introduzca el usuario por teclado
match opcion:
case 1:
print("📁 Abriendo archivo...")
case 2:
print("💾 Guardando cambios...")
case 3:
print("📤 Saliendo del programa...")
case _:
print("❌ Opción no reconocida. Inténtalo de nuevo.")
💡 Puntos clave a recordar:
- Cada línea de
casetermina obligatoriamente con dos puntos (:). - El código que pertenece a cada caso debe estar indentado con 4 espacios.
- A diferencia de lenguajes como C o Java, en Python no hace falta escribir
breakal final de cada caso; Python ejecuta únicamente el bloque coincidente y sale automáticamente de la estructura.
if-elif-else vs match-caseComparativa:
Observa cómo cambia la claridad del código al comparar el mismo algoritmo escrito con ambas técnicas:
Con if - elif - else:
codigo_http = 404
if codigo_http == 200:
mensaje = "Petición exitosa (OK)"
elif codigo_http == 301:
mensaje = "Redirección permanente"
elif codigo_http == 400:
mensaje = "Petición incorrecta (Bad Request)"
elif codigo_http == 404:
mensaje = "Recurso no encontrado (Not Found)"
elif codigo_http == 500:
mensaje = "Error interno del servidor"
else:
mensaje = "Código de estado desconocido"
Con match - case:
codigo_http = 404
match codigo_http:
case 200:
mensaje = "Petición exitosa (OK)"
case 301:
mensaje = "Redirección permanente"
case 400:
mensaje = "Petición incorrecta (Bad Request)"
case 404:
mensaje = "Recurso no encontrado (Not Found)"
case 500:
mensaje = "Error interno del servidor"
case _:
mensaje = "Código de estado desconocido"
print(f"Estado HTTP {codigo_http}: {mensaje}")
Opciones Múltiples con la Barra Vertical (|)
A veces queremos que varios valores distintos ejecuten exactamente la misma acción. En lugar de duplicar código o escribir varios casos iguales, podemos agruparlos en una sola línea separándolos con la pleca o barra vertical | (que funciona como un operador or).
dia= "sábado" #dia = input("Introduce un día de la semana: ").lower().strip()
match dia:
case "lunes" | "martes" | "miercoles" | "miércoles" | "jueves" | "viernes":
print("📚 Día lectivo: Hay que ir al instituto.")
case "sabado" | "sábado" | "domingo":
print("🎉 Fin de semana: Tiempo libre y descanso.")
case _:
print("❓ Ese no es un día válido.")
Casos con Filtros Condicionales: Guardas (if)
Una de las grandes ventajas de match-case frente a los switch tradicionales es que nos permite añadir una condición extra a un case mediante la palabra clave if. A esta condición complementaria se la denomina guarda (guard).
El bloque solo se ejecutará si el patrón coincide Y la condición de la guarda se evalúa como True.
nota= 9.3 #nota = float(input("Introduce la calificación final (0 a 10): "))
match nota:
case n if n < 0 or n > 10:
print("❌ Error: La nota debe estar comprendida entre 0 y 10.")
case n if n >= 9:
print("🌟 Sobresaliente")
case n if n >= 7:
print("📘 Notable")
case n if n >= 6:
print("📗 Bien")
case n if n >= 5:
print("📙 Suficiente")
case _:
print("🔴 Insuficiente")
📌 ¿Qué hace lanencase n if...?Al escribir un nombre de variable (en este cason) en elcase, Python vincula temporalmente el valor de la variable evaluada a ese identificador para poder comprobar la condición numérica.
Desempaquetado de Estructuras (Tuplas y Listas)
match-case permite verificar la forma de una lista o tupla directamente:# Simulador de órdenes recibidas por un robot móvil
comando = ["MOVER", 10, "NORTE"]
match comando:
case ["PARAR"]:
print("🛑 El robot detiene sus motores.")
case ["GIRAR", grados]:
print(f"🔄 Girando el chasis {grados}°.")
case ["MOVER", distancia, orientacion]:
print(f"🚀 Avanzando {distancia} metros con rumbo {orientacion}.")
case _:
print("⚠️ Comando corrupto o no reconocido por el microcontrolador.")
Errores Comunes de Principiante (¡Cuidado!)
- Olvidar los dos puntos (:): Tanto
match variable:como cada uno de loscase valor:deben terminar obligatoriamente con dos puntos. - Colocar el comodín _ antes del final: El
case _:debe ir siempre en la última posición. Si lo colocas al principio o en medio, absorberá cualquier valor e impedirá que los casos posteriores se comprueben. - Intentar usar operadores relacionales directamente en el valor:
- ❌ Incorrecto:
case >= 18: (provoca SyntaxError). - ✅ Correcto:
case edad if edad >= 18: (utilizando una guarda).
Estructuras de Control Repetitivas (Bucles)
Redacta la explicación de este punto...
contador = 1
while contador <= 5:
print(f"Iteración actual: {contador}")
contador += 1 # ⚠️ Mutación del contador de control
print("🏁 Bucle finalizado con éxito.")
Bucle for (Iteración sobre Colecciones y Secuencias)
En Python, el bucle for es un for-each: itera directamente sobre secuencias e iterables sin requerir un índice manual.
A. Iteración y range([inicio], parada, [paso])
# Iteración sobre lista
for lenguaje in ["Python", "Rust", "Go"]:
print(f"🚀 Tecnología: {lenguaje}")
# range(inicio, parada, paso)
for i in range(10, 0, -2):
print(i, end=" ") # Salida: 10 8 6 4 2
print() #salto de línea
print("🏁 Fin del programa")
B. Funciones auxiliares idiomáticas: enumerate(), zip() e .items()
Las funciones auxiliares idiomáticas en Python (enumerate(), zip() y .items()) son herramientas diseñadas para escribir código más limpio, legible y eficiente (lo que en la comunidad de Python se conoce como código pythonic). Su principal objetivo es evitar el uso de contadores manuales o índices innecesarios al recorrer estructuras de datos.
Aquí tienes la explicación detallada de cada una:
enumerate():
Sirve para obtener el índice y el valor al mismo tiempo.
Cuando recorres una lista con un bucle for, a veces necesitas saber en qué posición (índice) te encuentras. En lugar de crear una variable contador y sumarle 1 en cada iteración, enumerate() te da ambos datos automáticamente.
- Sintaxis básica:
enumerate(iterable, start=1)
frutas = ['manzana', 'plátano', 'uva']
for indice, fruta in enumerate(frutas):
print(f"Posición {indice}: {fruta}")
Nota: Puedes cambiar el inicio del conteo usando el argumento start (por ejemplo,enumerate(frutas, start=2)).
zip()
Sirve para recorrer dos o más secuencias en paralelo.
Si tienes dos listas distintas pero relacionadas y quieres combinar sus elementos uno a uno (como los dientes de una cremallera o zipper), zip() las agrupa en parejas (tuplas).
• Sintaxis básica: zip(iterable1, iterable2, ...)
nombres = ['Ana', 'Luis', 'Carlos']
edades = [25, 30, 35]
for nombre, edad in zip(nombres, edades):
print(f"{nombre} tiene {edad} años.")
Nota: Si las listas tienen tamaños diferentes, zip() se detendrá de forma predeterminada cuando la lista más corta se agote.
.items()
Sirve para recorrer las claves y los valores de un diccionario a la vez.
Por defecto, si haces un bucle for sobre un diccionario, Python solo te da las llaves (claves). El método .items() devuelve una vista de pares de elementos (clave, valor), lo que te permite desempaquetarlos directamente en el bucle.
• Sintaxis básica: diccionario.items()
capitales = {'España': 'Madrid', 'Francia': 'París', 'Italia': 'Roma'}
for pais, capital in capitales.items():
print(f"La capital de {pais} es {capital}.")
Funciones auxilares del bucle for
Abre el simulador y modifica el código para probarlo
Sentencias de Control de Saltos: break, continue y pass
| Sentencia | Sentencia | Comportamiento |
|---|---|---|
break | 🛑 Interrupción inmediata | Cancela la ejecución del bucle por completo y salta a la primera línea fuera de él. |
continue | ⏭️ Salto de iteración | Cancela el resto del cuerpo actual y pasa de inmediato a la siguiente iteración. |
pass | 💤 Operación nula (placeholder) | No ejecuta ninguna acción; sirve para mantener la sintaxis obligatoria de bloques vacíos. |
for numero in range(0,5):
if numero == 3:
pass # No hace nada, solo evita que Python dé un error de sintaxis
else:
print(numero)
for numero in range(0,5):
if numero == 3:
pass # No hace nada, solo evita que Python dé un error de sintaxis
else:
print(numero)
for numero in range(0,5):
if numero == 3:
pass # No hace nada, solo evita que Python dé un error de sintaxis
else:
print(numero)
La Cláusula else en Bucles
Tanto for como while admiten un bloque else opcional:
- Se ejecuta: Si el bucle finaliza de manera regular (completó todas las iteraciones o la condición del while se volvió False).
- Se omite: Si el bucle se interrumpe de forma anticipada mediante una instrucción break.
# Detección de números primos usando bucle-else
numero = 17
for divisor in range(2, int(numero ** 0.5) + 1):
if numero % divisor == 0:
print(f"❌ {numero} no es primo.")
break
else:
# Se ejecuta porque ningún divisor rompió el bucle con break
print(f"🌟 {numero} es un número primo confirmado.")
Auditoría financiera con for-else, break y continue
Procesa una serie de importes de transacciones bancarias. Si encuentras un importe negativo inferior a -100000 EUR, activa una alarma de posible fraude e interrumpe inmediatamente el proceso con break. Si una transacción es de 0.0 EUR, ignórala con continue. Si todas las transacciones son legítimas, ejecuta el bloque else del bucle para emitir un balance final conciliado y el total de operaciones válidas.
Simulador Auditoría financiera con for-else, break y continue
Abre el simulador y pruébalo modificando las instruciones