Python de Cero a Pro - Cap.5 Operadores y Condiciones Práctica

¡QuéPasaLinux! En este capítulo, realizaremos la práctica de los fundamentos de los operadores y las estructuras de control en Python. Es una forma práctica de aplicar los conceptos teóricos aprendidos en el capítulo anterior.

Síguenos con el tutorial

Python de Cero a Pro - Cap.5 Operadores y Condiciones

Volver a Página Principal

Ver Codigo en GitLab

🧮 Calculadora Dinámica CLI - Capacitación Python

📢 ¡Antes de empezar! No olvides suscribirte a mi canal de YouTube para más contenido.

Este proyecto consiste en una calculadora interactiva para la línea de comandos (CLI) que utiliza una interfaz dividida en dos columnas. El objetivo es enseñar los fundamentos de la programación modular, manejo de errores y manipulación de cadenas en Python.

🛠️ Conceptos Técnicos Utilizados

1. Gestión de Pantalla y Sistema (`os`)

os.name: Propiedad que identifica el sistema operativo. Retorna 'nt' para Windows y 'posix' para Linux/macOS.
os.system(): Ejecuta comandos de la terminal. Usamos cls (Windows) o clear (Unix) para limpiar la pantalla y que la calculadora no se repita infinitamente hacia abajo.
**col1 y col2**: Variables que definen el ancho de las columnas (45 y 35 espacios respectivamente). Gracias a los f-strings y al operador de alineación :, garantizamos que las barras separadoras | se mantengan alineadas sin importar el contenido.

2. Control de Errores y Excepciones

try...except: Bloque fundamental para evitar que el programa se cierre si el usuario comete un error (como escribir letras en lugar de números).
raise: Palabra clave utilizada para “lanzar” una excepción manualmente cuando detectamos algo que no es correcto lógicamente.
ZeroDivisionError: Excepción específica que ocurre cuando se intenta dividir por cero. En este código, la lanzamos manualmente con un mensaje amigable para el usuario.

3. Métodos de Listas y Strings

append(): Método que añade elementos al final de la lista historial. Cada operación exitosa se guarda aquí.
startswith(): Función de strings que verifica si la entrada comienza con uno o más caracteres específicos. Es vital para detectar operadores de dos caracteres como ** (potencia) o // (división entera).

💻 Código del Proyecto

Módulo: `calculos.py`

def ejecutar_operacion(simbolo, valor_actual, nuevo_valor):
    try:
        if simbolo == '+': return valor_actual + nuevo_valor
        elif simbolo == '-': return valor_actual - nuevo_valor
        elif simbolo == '*': return valor_actual * nuevo_valor
        elif simbolo == '/':
            if nuevo_valor == 0: raise ZeroDivisionError("División por cero")
            return valor_actual / nuevo_valor
        elif simbolo == '//':
            if nuevo_valor == 0: raise ZeroDivisionError("División entera por cero")
            return valor_actual // nuevo_valor
        elif simbolo == '%': return valor_actual % nuevo_valor
        elif simbolo == '**': return valor_actual ** nuevo_valor
        else: raise ValueError(f"Operador '{simbolo}' no reconocido")
    except Exception as e:
        raise e

def validar_entrada(entrada):
    try:
        if '.' in entrada: return float(entrada)
        return int(entrada)
    except ValueError:
        raise ValueError("El valor ingresado no es un número válido.")

Módulo: `calculadora.py`

import os
from calculos import ejecutar_operacion, validar_entrada

def limpiar_pantalla():
    os.system('cls' if os.name == 'nt' else 'clear')

def mostrar_interfaz(acumulado, historial, mensaje=""):
    limpiar_pantalla()
    col1, col2 = 45, 35
    filas_interfaz = 10

    print("=" * (col1 + col2 + 3))
    print(f"{' HISTORIAL DE OPERACIONES':<{col1}} | {' PANEL DE CONTROL':<{col2}}")
    print("-" * (col1 + col2 + 3))

    ultimas_ops = historial[-(filas_interfaz-2):] if historial else ["Esperando inicio..."]

    for i in range(filas_interfaz):
        txt_historial = ultimas_ops[i] if i < len(ultimas_ops) else ""
        txt_control = ""
        if i == 0: txt_control = "COMANDOS: clear, exit"
        elif i == 1: txt_control = "OPS: +, -, *, /, //, %, **"
        elif i == filas_interfaz - 1:
            txt_control = f"RESULTADO TOTAL: {acumulado}"

        print(f" {txt_historial:<{col1-1}} | {txt_control}")

    print("-" * (col1 + col2 + 3))
    if mensaje: print(f" [AVISO]: {mensaje}")
    else: print("")

def iniciar_calculadora():
    acumulado, historial, error = 0, [], ""

    while True:
        mostrar_interfaz(acumulado, historial, error)
        error = ""
        entrada = input(" DIGITE (Ej: +10) >> ").strip().lower()

        if entrada == 'exit': break
        if entrada == 'clear':
            acumulado, historial = 0, []
            continue

        try:
            op = ""
            if entrada.startswith(('**', '//')):
                op, num_str = entrada[:2], entrada[2:]
            elif entrada[:1] in "+-*/%":
                op, num_str = entrada[0], entrada[1:]
            else:
                num = validar_entrada(entrada)
                if not historial:
                    acumulado = num
                    historial.append(f"Inició con: {num}")
                else: error = "Error: Falta operador (ej: +5)"
                continue

            num = validar_entrada(num_str)
            nuevo_total = ejecutar_operacion(op, acumulado, num)
            historial.append(f"{acumulado} {op} {num} = {nuevo_total}")
            acumulado = nuevo_total
        except Exception as e:
            error = str(e)

if __name__ == "__main__":
    iniciar_calculadora()

📝 Guía de Ejercicios Prácticos

Límites de Seguridad: Modifica ejecutar_operacion en calculos.py para que lance una excepción si el resultado supera el millón (1,000,000).
Contador de Operaciones: Agrega una variable en calculadora.py que cuente cuántas operaciones se han realizado desde el último clear y muéstrala en el Panel de Control.
Formato de Historial: Cambia la forma en que se usa append() para que en lugar de guardar 10 + 5 = 15, guarde solo [SUMA] 5.
Confirmación de Salida: Modifica el comando exit para que, antes de cerrar, pregunte al usuario: “¿Está seguro que desea salir? (s/n)”.