Notes & Docs > 1BACH-CDYPD, 2BACH-TICII > TEMA 1: Fundamentos de programación
📍 Punto 1 Introducción y Conceptos Clave
1 / 7
1BACH-CDYPD · 1º BACH - Creación Digital y Pensamiento Computacional 2BACH-TICII · 2ºBACH - Tecnologías de la Información y la Comunicación II 🏷️ Programación PYTHON 👁️ 253 lecturas

TEMA 1: Fundamentos de programación

En este tema veremos los fundamentos básicos de la programación usando el lenguaje PYTHON.

#python #fundamentos #programación
Punto 1

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:

  1. Toma dos rebanadas de pan.
  2. Coloca una loncha de queso sobre una rebanada.
  3. Coloca una loncha de jamón sobre el queso.
  4. 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:

  1. Descomposición: Dividir un problema complejo en partes más pequeñas y manejables.
  2. Reconocimiento de Patrones: Identificar similitudes o tendencias entre problemas anteriores.
  3. Abstracción: Centrarse únicamente en la información importante e ignorar los detalles irrelevantes.
  4. 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:

💻 ¡Hola Mundo! PYTHON
print("¡Hola, mundo!")

En C++:

💻 ¡Hola Mundo! C++
#include <iostream>
using namespace std;

int main() {
    cout << "¡Hola, mundo!";
    return 0;
}
Imagen técnica

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?

🌐 ¿Por qué aprender Python? profesuite.com
Abrir en pestaña nueva ↗

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.

🎥 Conceptos de programación en 6 minutos
Punto 2

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:

  1. 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.
  2. 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.

Visual Studio Code (VS Code)  y el Intérprete de Python
Visual Studio Code (VS Code) y el Intérprete de Python

Guía de instalación según tu Sistema Operativo

Vamos a ver como istalarlo en EducAndOS v2, Windows 10/11, macOS.

  1. Intérprete de Python: Viene preinstalado de fábrica en el sistema. Puedes comprobarlo abriendo la Terminal (Ctrl + Alt + T) y escribiendo:

    python3 --version
    
  2. Instalació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):

      1. Entra en la web oficial: code.visualstudio.com.

      2. Descarga el paquete .deb (Debian/Ubuntu).

      3. Haz doble clic sobre el archivo descargado para abrir el instalador de paquetes y pulsa en Instalar.

  1. Instalación de Python:

    1. Entra en python.org/downloads.

    2. Haz clic en el botón amarillo Download Python 3.x.x.

    3. Ejecuta el archivo .exe descargado.

    4. ⚠️ PASO CRÍTICO: En la primera pantalla del instalador, marca obligatoriamente la casilla:

      ☑ Add python.exe to PATH (Añadir Python al PATH)

    5. Haz clic en Install Now y espera a que finalice.

  2. Instalación de Visual Studio Code:

    1. Entra en code.visualstudio.com.

    2. Descarga el instalador para Windows.

    3. Ejecuta el archivo y sigue el asistente dejando las opciones por defecto habilitadas (recomendado marcar "Agregar 'Abrir con Code' al menú contextual").

  1. Instalación de Python:

    1. Entra en python.org/downloads.

    2. Descarga el instalador del paquete .pkg para macOS.

    3. Haz doble clic y sigue los pasos del asistente de instalación.

  2. Instalación de Visual Studio Code:

    1. Entra en code.visualstudio.com.

    2. Descarga la versión para Mac (archivo .zip).

    3. 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ónCreador / BúsquedaFunción Principal
Spanish Language PackMicrosoftTraduce toda la interfaz de VS Code al español.
PythonMicrosoftAñade soporte completo para lenguaje Python, autocompletado y ejecución directa.
PylanceMicrosoftProporciona 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:

  1. Crea una carpeta de trabajo:

    • En tu equipo o pendrive, crea una carpeta llamada  Python.

  2. 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.

  3. 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 .py es fundamental para que el sistema sepa que es código Python).

  4. Escribe el código:

    • En el editor de texto a la derecha, escribe la siguiente línea:

💻 ¡Hola Mundo! PYTHON
# Mi primer programa en Python
print("¡Hola, Mundo!")
  1. 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.py

      • En EducAndOS v2 / Mac: python3 hola.py

Ejecución hola_mundo.py
Ejecución hola_mundo.py

Errores frecuentes y solución de problemas

  1. "python no se reconoce como un comando interno o externo..." (Windows):

    • Causa: Olvidaste marcar la casilla Add python.exe to PATH durante 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.

  2. 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.

  3. El intérprete no está seleccionado ("Select Interpreter"):

    • Solución: Pulsa Ctrl + Shift + P (o Cmd + Shift + P en Mac), escribe Python: Select Interpreter y selecciona la versión de Python instalada en tu sistema.

  4. 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.py para 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 instrucciones print().

  • 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 *).

Punto 3

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

  1. 🏁 Finito: Posee un punto de inicio y un número determinado de pasos con un final definido.
  2. 🎯 Preciso: Cada instrucción es rigurosa, clara y unívoca, sin margen de ambigüedad.
  3. 🔄 Definido: Dados idénticos datos de entrada, el algoritmo devuelve exactamente el mismo resultado en cada ejecución.
  4. ⚡ 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).

💻 Identación estrucuturada PYTHON
# 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.

💻 Comentarios en Python PYTHON
# 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.

  1. 🔀 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.
  2. 🛡️ 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 dinámica de tipos de datos PYTHON
#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_case para 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, Edad y EDAD son 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:

💻 Constantes PYTHON
#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")
🎯 Ejercicio Práctico

Declaración, documentación e intercambio de variables

📋 Enunciado

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.

Intenta resolverlo antes de consultar la solución oficial
⛶ Recurso Interactivo
🌐 domingoperez.profesuite.com

Inténtalo y prueba

Cambia los nombres y los mensajes que deses

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)

💻 Función Print() PYTHON
#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:

  1. 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.

💻 Paso de múltiples argumentos por coma PYTHON
nombre = "Laura"
edad = 26
print("Usuario:", nombre, "| Edad:", edad)
# Salida: Usuario: Laura | Edad: 26
2. Operador de concatenación (+):
  • Une exclusivamente cadenas de texto (str).

  • Requiere casting explícito previo: intentar concatenar tipos numéricos genera un error TypeError.

💻 Concatenación de textos PYTHON
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).

💻 Método .format() PYTHON
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))
4. Cadenas literales formateadas (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 {}.

💻 Método f-strings PYTHON
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.
💻 Control de separadores y Saltos de línea PYTHON
# 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)
💻 Contro de decimales PYTHON
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
💻 Notación Monetaria PYTHON
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 (%)
Multiplica automáticamente el valor por $100$ y añade el símbolo %:
💻 Notación porcentual (%) PYTHON
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)
💻 Notación científica PYTHON
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

EspecificadorSignificadoEntradaCódigoSalida
:0NdRellena con ceros hasta $N$ dígitos enteros

42

{42:05d}

'00042'

:<N

Alinea a la izquierda con un ancho de $N$

"Python"

{"Python":<10}

'Python '

:>N

Alinea a la derecha con un ancho de $N$

75.5

{75.5:>10}

' 75.5'

:^N

Alinea al centro con un ancho de $N$

"OK"

{"OK":^10}

' OK '


💻 Relleno, alineación y anchura de collumnas PYTHON
# 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)
💻 Conversión (Binario, Octal, Hexadecimal) PYTHON
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).

💻 input() PYTHON
#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)

El casting consiste en transformar explícita o implícitamente un dato entre distintos tipos.
Conversión Implícita (Coerción)

El intérprete promociona tipos menores a mayores para evitar truncamiento o pérdida de precisión.

💻 Coerción PYTHON
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.

ConstructorFunción y PropósitoEjemplo PrácticoResultado Obtenido

int(x)

🔢 Convierte a entero (trunca decimales o parsea dígitos)

int("75") / int(8.99)

75 / 8

float(x)

🌐 Convierte a número de coma flotante

float("19.5") / float(4)

19.5 / 4.0

str(x)

🔤 Genera representación en texto

str(1024)

"1024"

bool(x)

⚖️ Evalúa el valor de verdad booleano

bool(1) / bool("")

True / False

💻 Código de Ejemplo PYTHON
#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} €")
🎯 Ejercicio Práctico

Factura comercial con input(), casting y formato tabular

Nivel básico
📋 Enunciado

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.

Intenta resolverlo antes de consultar la solución oficial
⛶ Recurso Interactivo
🌐 domingoperez.profesuite.com

Factura comerial con input(), casting y formato tabular.

Abre el simulador y haz cambios y pruébalos

Pestaña nueva ↗

Operadores en Python

Operadores Aritméticos

Ejecutan operaciones matemáticas sobre operandos numéricos:

💻 Operadores PYTHON
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):

💻 Operadores de Comparación PYTHON
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?
En programación, muchas veces no nos basta con hacer una sola pregunta (por ejemplo: ¿el usuario es mayor de edad?). En la vida real tomamos decisiones combinando varias condiciones a la vez:
    • "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."
Los operadores lógicos (también llamados operadores booleanos en honor al matemático George Boole) nos permiten unir o modificar expresiones que devuelven True (Verdadero) o False (Falso).
En Python existen exactamente tres operadores lógicos y se escriben en inglés con minúsculas: and, or y not.

El Operador and (Conjunción - "Y")
El operador 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.

💡 Analogía de clase

Imagina una puerta de alta seguridad con dos cerraduras en serie. Para abrir la puerta necesitas tener la Llave 1 Y la Llave 2. Si solo tienes una de las dos, la puerta no se abre.

📊 Tabla de Verdad del operador and
Condición ACondición BResultado (A and B)
FalseFalse❌ False
FalseTrue❌ False
TrueFalse❌ False
TrueTrue✅ True
Combinan expresiones booleanas y aplican evaluación en cortocircuito (short-circuit):
💻 Ejemplo operador lógico AND PYTHON
# 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 ACondición BResultado (A OR B)
FalseFalse❌ False
FalseTrue✅ True
TrueFalse✅ True
TrueTrue✅ True
💻 Ejemplo operador lógico OR PYTHON
# 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")
A diferencia de los anteriores, 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.

📊 Tabla de Verdad del operador not

Condición AResultado (not A)
True❌ False
False✅ True

💻 Ejemplo operador lógico NOT PYTHON
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:

💻 Operadores de Membresía PYTHON
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:


💻 Omitir la variable tras el operador lógico PYTHON
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):


💻 Confundir and y or al comprobar rangos numéricos PYTHON
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.


⛶ Recurso Interactivo
🌐 domingoperez.profesuite.com

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

💻 Código de Ejemplo PYTHON
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 ⛅'}")
Punto 4

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).

💻 Enteros PYTHON
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.

💻 Flotantes PYTHON
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}$):

💻 Complejos PYTHON
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.

💻 Textos PYTHON
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)

Subtipo numérico que solo admite dos valores: True (1) y False (0).

Colecciones y Estructuras de Datos

📦 Estructuras de Datos
 ├── 📜 Listas [ ]                    -> Ordenadas, Mutables, Admiten Duplicados
 ├── 🔒 Tuplas ( )                  -> Ordenadas, Inmutables, Admiten Duplicados
 ├── 🎯 Conjuntos { }       -> Desordenados, Mutables, Elementos Únicos
 └── 🗂️ Diccionarios { } -> Pares Clave:Valor, Claves Únicas e Inmutables

Listas (list)

Secuencias mutables, indexadas numéricamente y aptas para colecciones heterogéneas.
💻 Listas PYTHON
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)

Secuencias ordenadas estrictamente inmutables. Se utilizan para salvaguardar la integridad de los datos frente a modificaciones accidentales.
💻 Tuplas PYTHON
# 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)

Colecciones mutables de elementos únicos y no ordenados. Se implementan internamente mediante tablas hash ($O(1)$ en operaciones de pertenencia). Solo admiten objetos inmutables (hashable).
💻 Conjuntos PYTHON
# 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)

Colecciones de pares clave: valor. Desde Python 3.7 preservan el orden de inserción de las claves.

    • 🔑 Claves: Deben ser objetos inmutables y únicos (str, int, tuple).
    • 📦 Valores: Pueden ser de cualquier tipo y admiten duplicados.
💻 Diccionarios PYTHON
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ónSintaxis ¿Ordenada?¿Mutable?¿Admite Duplicados?Acceso a ElementosCaso de Uso Habitual
📜 Lista

[1, 2, 3]

Sí

Sí

Sí

Por índice entero (l[0])

Secuencias dinámicas modificables

🔒 Tupla

(1, 2, 3)

Sí

No

Sí

Por índice entero (t[0])

Registros fijos, claves compuestas

🎯 Conjunto

{1, 2, 3}

No

Sí

No

Por pertenencia (x in s)

Unicidad y operaciones de conjuntos

🗂️ Diccionario

{"k": "v"}

Sí (inserción)

Sí

Claves no, valores sí

Por clave única (d["k"])

Mapeo de atributos y consultas directas

Punto 5

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).

La mágia de la toma de decisiones
La mágia de la toma de decisiones

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:

    1. La expresión condicional finaliza obligatoriamente con dos puntos (:).
    2. El bloque que compone la acción debe estar indentado obligatoriamente (4 espacios).
    3. La cláusula else es opcional; no evalúa ninguna condición propia y solo se dispara cuando el if precedente evalúa a False.

💻 if.. else PYTHON
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 los elif y el else restantes.
    • El bloque final else actúa como un comportamiento por defecto (fallback) cuando ninguna de las condiciones anteriores se cumplió.

💻 if..elif..else PYTHON
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.

💻 Neste if..else PYTHON
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:

    1. Operadores lógicos (and, or): para unir condiciones interdependientes.
    2. 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 es False, no se evalúan las siguientes, porque el resultado final inevitablemente será False.
    • En un bloque con or: si la primera subcondición es True, no se evalúan las siguientes, porque el resultado final inevitablemente ya será True.

💻 Operadores lógicos PYTHON
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.")
🎯 Ejercicio Práctico

Sistema de autorización por niveles con anidamiento

Nivel medio esturcta control if elif. else
📋 Enunciado

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.

Intenta resolverlo antes de consultar la solución oficial
⛶ Recurso Interactivo
🌐 domingoperez.profesuite.com

Simulador Sistema de autorización por niveles con anidamiento

Abre el simulador y haz los cambios que quieras.

Punto 6

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 y funcionamiento de match en Python
Sintaxis y funcionamiento de match en Python

Sintaxis Básica y Reglas de Escritura

La estructura requiere dos palabras clave fundamentales:

    1. match: indica la variable o expresión que queremos inspeccionar.
    2. case: define cada una de las opciones posibles que queremos comprobar.
    3. _ (guion bajo): actúa como el caso por defecto (comodín o wildcard). Si ningún case previo ha coincidido, se ejecuta este bloque (cumple la misma función que el else final).

💻 Estructura de match-case PYTHON
# ====================================================================
# 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 case termina 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 break al 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:


💻 Con if - elif - else: PYTHON
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:

💻 Con match - case: PYTHON
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).


💻 Opciones multiples match - case PYTHON
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.


💻 Match con filtros condicionales (Guardas if) PYTHON
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 la n en case n if ...?
Al escribir un nombre de variable (en este caso n) en el case, 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)

En proyectos de robótica, videojuegos o tratamiento de datos, a menudo trabajamos con coordenadas o secuencias. match-case permite verificar la forma de una lista o tupla directamente:

💻 Desempaquetado de tuplas y listas PYTHON
# 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!)

  1. Olvidar los dos puntos (:): Tanto match variable: como cada uno de los case valor: deben terminar obligatoriamente con dos puntos.
  2. 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.
  3. Intentar usar operadores relacionales directamente en el valor:
    • ❌ Incorrecto: case >= 18: (provoca SyntaxError).
    • ✅ Correcto: case edad if edad >= 18: (utilizando una guarda).


Punto 7

Estructuras de Control Repetitivas (Bucles)

Redacta la explicación de este punto...

💻 Bucle While PYTHON
contador = 1

while contador <= 5:
    print(f"Iteración actual: {contador}")
    contador += 1  # ⚠️ Mutación del contador de control

print("🏁 Bucle finalizado con éxito.")
⛶ Recurso Interactivo
🌐 domingoperez.profesuite.com

Lista de elementos y texto a buscar

Abre el simulador y practica cambiando datos

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 una lista y range PYTHON
# 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")
🌐 Bucle For - Factorial en python profesuite.com
Abrir en pestaña nueva ↗

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)
💻 enumerate() PYTHON
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, ...)

💻 zip() PYTHON
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()


💻 .items() PYTHON
capitales = {'España': 'Madrid', 'Francia': 'París', 'Italia': 'Roma'}

for pais, capital in capitales.items():
    print(f"La capital de {pais} es {capital}.")
⛶ Recurso Interactivo
🌐 domingoperez.profesuite.com

Funciones auxilares del bucle for

Abre el simulador y modifica el código para probarlo

Sentencias de Control de Saltos: break, continue y pass

SentenciaSentenciaComportamiento
break🛑 Interrupción inmediataCancela la ejecución del bucle por completo y salta a la primera línea fuera de él.
continue⏭️ Salto de iteraciónCancela 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.



💻 break PYTHON
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)
💻 continue PYTHON
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)
💻 pass PYTHON
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.

💻 else en bucles PYTHON
# 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.")
🎯 Ejercicio Práctico

Auditoría financiera con for-else, break y continue

Nivel Medio - python
📋 Enunciado

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.

Intenta resolverlo antes de consultar la solución oficial
⛶ Recurso Interactivo
🌐 domingoperez.profesuite.com

Simulador Auditoría financiera con for-else, break y continue

Abre el simulador y pruébalo modificando las instruciones